From 2840f25a80be8e3e229168687f80ef219385b6a6 Mon Sep 17 00:00:00 2001 From: xiongcz Date: Fri, 6 Jun 2025 15:23:57 +0800 Subject: [PATCH] 1 --- .gitignore | 389 + .idea/.gitignore | 8 + .idea/misc.xml | 64 + CONNOR_ITK/CONNOR_ITK.vcxproj | 153 + CONNOR_ITK/CONNOR_ITK.vcxproj.filters | 82 + CONNOR_ITK/JLCS_05.cxx | 973 ++ CONNOR_ITK/JLCS_05_MasterData.cxx | 1206 ++ CONNOR_ITK/JL_Add_FinishTime.cpp | 336 + .../JL_Change_Inspection_Of_Basic_Part.cxx | 2383 ++++ CONNOR_ITK/JL_Send_Mail.cxx | 628 + CONNOR_ITK/JL_Send_Order_Process.cxx | 229 + CONNOR_ITK/JL_Target_Moveto_Annex.cpp | 268 + CONNOR_ITK/JL_Welding_Syetem.cpp | 121 + CONNOR_ITK/JL_form_save.cpp | 155 + CONNOR_ITK/common_itk_util.c | 288 + CONNOR_ITK/common_itk_util.h | 39 + CONNOR_ITK/connor_custom_main.cxx | 44 + CONNOR_ITK/epm_handler_common.h | 60 + CONNOR_ITK/epm_register_handler.cxx | 499 + CONNOR_ITK/epm_register_handler.h | 21 + CONNOR_ITK/jl_dmu_auto.cxx | 281 + CONNOR_ITK/jl_insert_img_pdf.cxx | 1007 ++ CONNOR_ITK/jl_insert_modular.cxx | 196 + CONNOR_ITK/jl_locomotion_item.cxx | 140 + CONNOR_ITK/ocilib.cxx | 439 + CONNOR_ITK/ocilib.h | 98 + JL_ITK.sln | 28 + OCI/include/nzerror.h | 674 + OCI/include/nzt.h | 2387 ++++ OCI/include/occi.h | 78 + OCI/include/occiAQ.h | 374 + OCI/include/occiCommon.h | 982 ++ OCI/include/occiControl.h | 2137 +++ OCI/include/occiData.h | 1167 ++ OCI/include/occiObjects.h | 910 ++ OCI/include/oci.h | 3045 +++++ OCI/include/oci1.h | 182 + OCI/include/oci8dp.h | 317 + OCI/include/ociap.h | 11122 ++++++++++++++++ OCI/include/ociapr.h | 155 + OCI/include/ocidef.h | 886 ++ OCI/include/ocidem.h | 113 + OCI/include/ocidfn.h | 249 + OCI/include/ociextp.h | 282 + OCI/include/ocikpr.h | 165 + OCI/include/ocilib.h | 98 + OCI/include/ocixml.h | 188 + OCI/include/ocixmldb.h | 141 + OCI/include/ocixstream.h | 1899 +++ OCI/include/odci.h | 798 ++ OCI/include/oratypes.h | 322 + OCI/include/ori.h | 2095 +++ OCI/include/orid.h | 373 + OCI/include/orl.h | 3633 +++++ OCI/include/oro.h | 883 ++ OCI/include/ort.h | 2594 ++++ OCI/include/xa.h | 200 + OCI/lib/MSVC/vc8/oraocci11.sym | Bin 0 -> 1137728 bytes OCI/lib/MSVC/vc8/oraocci11d.sym | Bin 0 -> 1589568 bytes OCI/lib/MSVC/vc9/oraocci11.sym | Bin 0 -> 1417200 bytes OCI/lib/MSVC/vc9/oraocci11d.sym | Bin 0 -> 3037456 bytes README.md | 6 + 62 files changed, 48590 insertions(+) create mode 100644 .gitignore create mode 100644 .idea/.gitignore create mode 100644 .idea/misc.xml create mode 100644 CONNOR_ITK/CONNOR_ITK.vcxproj create mode 100644 CONNOR_ITK/CONNOR_ITK.vcxproj.filters create mode 100644 CONNOR_ITK/JLCS_05.cxx create mode 100644 CONNOR_ITK/JLCS_05_MasterData.cxx create mode 100644 CONNOR_ITK/JL_Add_FinishTime.cpp create mode 100644 CONNOR_ITK/JL_Change_Inspection_Of_Basic_Part.cxx create mode 100644 CONNOR_ITK/JL_Send_Mail.cxx create mode 100644 CONNOR_ITK/JL_Send_Order_Process.cxx create mode 100644 CONNOR_ITK/JL_Target_Moveto_Annex.cpp create mode 100644 CONNOR_ITK/JL_Welding_Syetem.cpp create mode 100644 CONNOR_ITK/JL_form_save.cpp create mode 100644 CONNOR_ITK/common_itk_util.c create mode 100644 CONNOR_ITK/common_itk_util.h create mode 100644 CONNOR_ITK/connor_custom_main.cxx create mode 100644 CONNOR_ITK/epm_handler_common.h create mode 100644 CONNOR_ITK/epm_register_handler.cxx create mode 100644 CONNOR_ITK/epm_register_handler.h create mode 100644 CONNOR_ITK/jl_dmu_auto.cxx create mode 100644 CONNOR_ITK/jl_insert_img_pdf.cxx create mode 100644 CONNOR_ITK/jl_insert_modular.cxx create mode 100644 CONNOR_ITK/jl_locomotion_item.cxx create mode 100644 CONNOR_ITK/ocilib.cxx create mode 100644 CONNOR_ITK/ocilib.h create mode 100644 JL_ITK.sln create mode 100644 OCI/include/nzerror.h create mode 100644 OCI/include/nzt.h create mode 100644 OCI/include/occi.h create mode 100644 OCI/include/occiAQ.h create mode 100644 OCI/include/occiCommon.h create mode 100644 OCI/include/occiControl.h create mode 100644 OCI/include/occiData.h create mode 100644 OCI/include/occiObjects.h create mode 100644 OCI/include/oci.h create mode 100644 OCI/include/oci1.h create mode 100644 OCI/include/oci8dp.h create mode 100644 OCI/include/ociap.h create mode 100644 OCI/include/ociapr.h create mode 100644 OCI/include/ocidef.h create mode 100644 OCI/include/ocidem.h create mode 100644 OCI/include/ocidfn.h create mode 100644 OCI/include/ociextp.h create mode 100644 OCI/include/ocikpr.h create mode 100644 OCI/include/ocilib.h create mode 100644 OCI/include/ocixml.h create mode 100644 OCI/include/ocixmldb.h create mode 100644 OCI/include/ocixstream.h create mode 100644 OCI/include/odci.h create mode 100644 OCI/include/oratypes.h create mode 100644 OCI/include/ori.h create mode 100644 OCI/include/orid.h create mode 100644 OCI/include/orl.h create mode 100644 OCI/include/oro.h create mode 100644 OCI/include/ort.h create mode 100644 OCI/include/xa.h create mode 100644 OCI/lib/MSVC/vc8/oraocci11.sym create mode 100644 OCI/lib/MSVC/vc8/oraocci11d.sym create mode 100644 OCI/lib/MSVC/vc9/oraocci11.sym create mode 100644 OCI/lib/MSVC/vc9/oraocci11d.sym create mode 100644 README.md diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..c102fe8 --- /dev/null +++ b/.gitignore @@ -0,0 +1,389 @@ +# ---> VisualStudio +## Ignore Visual Studio temporary files, build results, and +## files generated by popular Visual Studio add-ons. +## +## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore + +# User-specific files +*.rsuser +*.suo +*.user +*.userosscache +*.sln.docstates + +# User-specific files (MonoDevelop/Xamarin Studio) +*.userprefs + +# Mono auto generated files +mono_crash.* + +# Build results +[Dd]ebug/ +[Dd]ebugPublic/ +[Rr]elease/ +[Rr]eleases/ +x64/ +x86/ +[Aa][Rr][Mm]/ +[Aa][Rr][Mm]64/ +bld/ +[Bb]in/ +[Oo]bj/ +[Ll]og/ +[Ll]ogs/ + +# Visual Studio 2015/2017 cache/options directory +.vs/ +# Uncomment if you have tasks that create the project's static files in wwwroot +#wwwroot/ + +# Visual Studio 2017 auto generated files +Generated\ Files/ + +# MSTest test Results +[Tt]est[Rr]esult*/ +[Bb]uild[Ll]og.* + +# NUnit +*.VisualState.xml +TestResult.xml +nunit-*.xml + +# Build Results of an ATL Project +[Dd]ebugPS/ +[Rr]eleasePS/ +dlldata.c + +# Benchmark Results +BenchmarkDotNet.Artifacts/ + +# .NET Core +project.lock.json +project.fragment.lock.json +artifacts/ + +# StyleCop +StyleCopReport.xml + +# Files built by Visual Studio +*_i.c +*_p.c +*_h.h +*.ilk +*.meta +*.obj +*.iobj +*.pch +*.pdb +*.ipdb +*.pgc +*.pgd +*.rsp +*.sbr +*.tlb +*.tli +*.tlh +*.tmp +*.tmp_proj +*_wpftmp.csproj +*.log +*.vspscc +*.vssscc +.builds +*.pidb +*.svclog +*.scc + +# Chutzpah Test files +_Chutzpah* + +# Visual C++ cache files +ipch/ +*.aps +*.ncb +*.opendb +*.opensdf +*.sdf +*.cachefile +*.VC.db +*.VC.VC.opendb + +# Visual Studio profiler +*.psess +*.vsp +*.vspx +*.sap + +# Visual Studio Trace Files +*.e2e + +# TFS 2012 Local Workspace +$tf/ + +# Guidance Automation Toolkit +*.gpState + +# ReSharper is a .NET coding add-in +_ReSharper*/ +*.[Rr]e[Ss]harper +*.DotSettings.user + +# TeamCity is a build add-in +_TeamCity* + +# DotCover is a Code Coverage Tool +*.dotCover + +# AxoCover is a Code Coverage Tool +.axoCover/* +!.axoCover/settings.json + +# Coverlet is a free, cross platform Code Coverage Tool +coverage*[.json, .xml, .info] + +# Visual Studio code coverage results +*.coverage +*.coveragexml + +# NCrunch +_NCrunch_* +.*crunch*.local.xml +nCrunchTemp_* + +# MightyMoose +*.mm.* +AutoTest.Net/ + +# Web workbench (sass) +.sass-cache/ + +# Installshield output folder +[Ee]xpress/ + +# DocProject is a documentation generator add-in +DocProject/buildhelp/ +DocProject/Help/*.HxT +DocProject/Help/*.HxC +DocProject/Help/*.hhc +DocProject/Help/*.hhk +DocProject/Help/*.hhp +DocProject/Help/Html2 +DocProject/Help/html + +# Click-Once directory +publish/ + +# Publish Web Output +*.[Pp]ublish.xml +*.azurePubxml +# Note: Comment the next line if you want to checkin your web deploy settings, +# but database connection strings (with potential passwords) will be unencrypted +*.pubxml +*.publishproj + +# Microsoft Azure Web App publish settings. Comment the next line if you want to +# checkin your Azure Web App publish settings, but sensitive information contained +# in these scripts will be unencrypted +PublishScripts/ + +# NuGet Packages +*.nupkg +# NuGet Symbol Packages +*.snupkg +# The packages folder can be ignored because of Package Restore +**/[Pp]ackages/* +# except build/, which is used as an MSBuild target. +!**/[Pp]ackages/build/ +# Uncomment if necessary however generally it will be regenerated when needed +#!**/[Pp]ackages/repositories.config +# NuGet v3's project.json files produces more ignorable files +*.nuget.props +*.nuget.targets + +# Microsoft Azure Build Output +csx/ +*.build.csdef + +# Microsoft Azure Emulator +ecf/ +rcf/ + +# Windows Store app package directories and files +AppPackages/ +BundleArtifacts/ +Package.StoreAssociation.xml +_pkginfo.txt +*.appx +*.appxbundle +*.appxupload + +# Visual Studio cache files +# files ending in .cache can be ignored +*.[Cc]ache +# but keep track of directories ending in .cache +!?*.[Cc]ache/ + +# Others +ClientBin/ +~$* +*~ +*.dbmdl +*.dbproj.schemaview +*.jfm +*.pfx +*.publishsettings +orleans.codegen.cs + +# Including strong name files can present a security risk +# (https://github.com/github/gitignore/pull/2483#issue-259490424) +#*.snk + +# Since there are multiple workflows, uncomment next line to ignore bower_components +# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622) +#bower_components/ + +# RIA/Silverlight projects +Generated_Code/ + +# Backup & report files from converting an old project file +# to a newer Visual Studio version. Backup files are not needed, +# because we have git ;-) +_UpgradeReport_Files/ +Backup*/ +UpgradeLog*.XML +UpgradeLog*.htm +ServiceFabricBackup/ +*.rptproj.bak + +# SQL Server files +*.mdf +*.ldf +*.ndf + +# Business Intelligence projects +*.rdl.data +*.bim.layout +*.bim_*.settings +*.rptproj.rsuser +*- [Bb]ackup.rdl +*- [Bb]ackup ([0-9]).rdl +*- [Bb]ackup ([0-9][0-9]).rdl + +# Microsoft Fakes +FakesAssemblies/ + +# GhostDoc plugin setting file +*.GhostDoc.xml + +# Node.js Tools for Visual Studio +.ntvs_analysis.dat +node_modules/ + +# Visual Studio 6 build log +*.plg + +# Visual Studio 6 workspace options file +*.opt + +# Visual Studio 6 auto-generated workspace file (contains which files were open etc.) +*.vbw + +# Visual Studio LightSwitch build output +**/*.HTMLClient/GeneratedArtifacts +**/*.DesktopClient/GeneratedArtifacts +**/*.DesktopClient/ModelManifest.xml +**/*.Server/GeneratedArtifacts +**/*.Server/ModelManifest.xml +_Pvt_Extensions + +# Paket dependency manager +.paket/paket.exe +paket-files/ + +# FAKE - F# Make +.fake/ + +# CodeRush personal settings +.cr/personal + +# Python Tools for Visual Studio (PTVS) +__pycache__/ +*.pyc + +# Cake - Uncomment if you are using it +# tools/** +# !tools/packages.config + +# Tabs Studio +*.tss + +# Telerik's JustMock configuration file +*.jmconfig + +# BizTalk build output +*.btp.cs +*.btm.cs +*.odx.cs +*.xsd.cs + +# OpenCover UI analysis results +OpenCover/ + +# Azure Stream Analytics local run output +ASALocalRun/ + +# MSBuild Binary and Structured Log +*.binlog + +# NVidia Nsight GPU debugger configuration file +*.nvuser + +# MFractors (Xamarin productivity tool) working folder +.mfractor/ + +# Local History for Visual Studio +.localhistory/ + +# BeatPulse healthcheck temp database +healthchecksdb + +# Backup folder for Package Reference Convert tool in Visual Studio 2017 +MigrationBackup/ + +# Ionide (cross platform F# VS Code tools) working folder +.ionide/ + +# ---> C++ +# Prerequisites +*.d + +# Compiled Object files +*.slo +*.lo +*.o +*.obj + +# Precompiled Headers +*.gch +*.pch + +# Compiled Dynamic libraries +*.so +*.dylib +*.dll + +# Fortran module files +*.mod +*.smod + +# Compiled Static libraries +*.lai +*.la +*.a +*.lib + +# Executables +*.exe +*.out +*.app + diff --git a/.idea/.gitignore b/.idea/.gitignore new file mode 100644 index 0000000..463c03e --- /dev/null +++ b/.idea/.gitignore @@ -0,0 +1,8 @@ +# ĬϺԵļ +/shelf/ +/workspace.xml +# ڱ༭ HTTP ͻ +/httpRequests/ +# Datasource local storage ignored files +/dataSources/ +/dataSources.local.xml diff --git a/.idea/misc.xml b/.idea/misc.xml new file mode 100644 index 0000000..937db7d --- /dev/null +++ b/.idea/misc.xml @@ -0,0 +1,64 @@ + + + + + + + + JUnit + + + JVM 语言 + + + Java + + + Java 5Java 语言级别迁移帮助Java + + + Java 8Java 语言级别迁移帮助Java + + + Java 语言级别迁移帮助Java + + + JavadocJava + + + Spring + + + Spring AOPSpring + + + TestNGJava + + + 代码成熟度Java + + + 性能Java + + + 数值问题Java + + + 类结构Java + + + 线程问题Java + + + 编译器问题Java + + + + + 用户定义 + + + + + + \ No newline at end of file diff --git a/CONNOR_ITK/CONNOR_ITK.vcxproj b/CONNOR_ITK/CONNOR_ITK.vcxproj new file mode 100644 index 0000000..1c56154 --- /dev/null +++ b/CONNOR_ITK/CONNOR_ITK.vcxproj @@ -0,0 +1,153 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + Debug + x64 + + + Release + x64 + + + + {A5936B6A-CCDE-41C6-A5EC-5D8CAF769F7F} + CONNOR_ITK + 10.0 + JL_ITK + + + + Application + true + v142 + MultiByte + + + Application + false + v142 + true + MultiByte + + + Application + true + v142 + MultiByte + + + DynamicLibrary + false + false + Unicode + v142 + + + + + + + + + + + + + + + + + + + + + .dll + + + + Level3 + Disabled + true + + + + + Level3 + Disabled + true + D:\peixun\tc11_EVN\include;D:\peixun\tc11_EVN\include_cpp;%(AdditionalIncludeDirectories) + ProgramDatabase + + + D:\peixun\tc11_EVN\*.lib;%(AdditionalDependencies) + + + + + Level3 + MaxSpeed + true + true + true + + + true + true + + + + + Level3 + MaxSpeed + true + true + true + C:\environment\Teamcenter-ENV\ITK_Configuration_File\JL_ITK\libxl\libxl\include;C:\environment\Teamcenter-ENV\ITK_Configuration_File\JL_ITK\include_cpp;C:\environment\Teamcenter-ENV\ITK_Configuration_File\JL_ITK\include;C:\Users\Administrator\Desktop\依赖包\include;C:\Users\Administrator\Desktop\依赖包\include_cpp;C:\Users\Administrator\Desktop\依赖包\libxl\libxl\include;$(SolutionDir)OCI\include;%(AdditionalIncludeDirectories) + _CRT_NONSTDC_NO_DEPRECATE;_CRT_SECURE_NO_WARNINGS;WIN32;NDEBUG;_CONSOLE;IPLIB=none;%(PreprocessorDefinitions) + + + true + true + $(OutDir)\jl.dll + C:\Users\Administrator\Desktop\依赖包\lib\*.lib;C:\Users\Administrator\Desktop\依赖包\libxl\libxl\lib\*.lib;C:\environment\Teamcenter-ENV\ITK_Configuration_File\JL_ITK\lib\*.lib;C:\environment\Teamcenter-ENV\ITK_Configuration_File\JL_ITK\libxl\libxl\lib\*.lib;%(AdditionalDependencies) + Console + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/CONNOR_ITK/CONNOR_ITK.vcxproj.filters b/CONNOR_ITK/CONNOR_ITK.vcxproj.filters new file mode 100644 index 0000000..99568c3 --- /dev/null +++ b/CONNOR_ITK/CONNOR_ITK.vcxproj.filters @@ -0,0 +1,82 @@ + + + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hh;hpp;hxx;hm;inl;inc;xsd + + + {ca041e83-7fab-47f9-b6e5-089441e62ecf} + + + {48795282-4973-45c1-8088-ec3dc4f3c98c} + + + + + common + + + common + + + handler + + + handler + + + handler + + + handler + + + handler + + + handler + + + common + + + handler + + + handler + + + handler + + + handler + + + handler + + + handler + + + handler + + + handler + + + + + 头文件 + + + 头文件 + + + common + + + handler + + + \ No newline at end of file diff --git a/CONNOR_ITK/JLCS_05.cxx b/CONNOR_ITK/JLCS_05.cxx new file mode 100644 index 0000000..acb62f5 --- /dev/null +++ b/CONNOR_ITK/JLCS_05.cxx @@ -0,0 +1,973 @@ +#define _CRT_SECURE_NO_WARNINGS +#include "epm_handler_common.h" + +#include +#include +#import "C:\Program Files\Common Files\System\ado\msado15.dll" no_namespace rename("EOF","adoEOF")rename("BOF","adoBOF") + +#include + +#include +#include +#include +#include + +#include +#include +#include +#include +#pragma warning(disable : 4996) +#include +#include +#include +#include +extern "C" int POM_AM__set_application_bypass(logical bypass); +using namespace std; + +#define DOFREE(obj) \ +{ \ + if(obj) \ + { \ + MEM_free(obj); \ + obj = NULL; \ + } \ +} + +char *MATNR, *WERKS, *STLAN, *STALT, *VBELN, *VBPOS, *BMENG, *POSNR, *POSTP, *IDNRK, *MENGE, *MEINS, *POTX1, *POTX2; +// +void getBomPropertys(EPM_action_message_t msg, int ifail); +void getBomLinePropertys(tag_t top_line,char *type); +void getBomLinePropertysBom(tag_t top_line,string topUUID,char * carModel, _ConnectionPtr m_pConnection); +int countNum = 1; +long countInsertSql = 0; +//int countNumCoe = countNum * 512; +char *parameters; + +string getUUid() +{ + char buffer[64] = { 0 }; + GUID guid; + + if ( CoCreateGuid(&guid) ) + { + fprintf(stderr, "create guid error\n"); + return ""; + } + _snprintf(buffer, sizeof(buffer),"%08X-%04X-%04x-%02X%02X-%02X%02X%02X%02X%02X%02X",guid.Data1, guid.Data2, guid.Data3, + guid.Data4[0], guid.Data4[1], guid.Data4[2],guid.Data4[3], guid.Data4[4], guid.Data4[5],guid.Data4[6], guid.Data4[7]); + //printf("guid: %s\n", buffer); + + return buffer; +} + +int JLCS_05_BOMSendOutSap_Single(EPM_action_message_t msg) +{ + printf("ʼִ\n"); + int ifail = ITK_ok; + + parameters = (char*)malloc(100000 * sizeof(char)); + strcpy(parameters, "getBomPropertys}}"); + //parameters = "getBomPropertys}}"; + printf("parameters1:\n%s\n", parameters); + int attachments_num; + int bvr_count; + tag_t rootTask = NULLTAG, *attachments = NULLTAG, top_line = NULLTAG, *children_line = NULLTAG, *bvr_list = NULLTAG; + tag_t bom_window_tag; + char *object_type = NULL; + int count; + + char *tc_root_file = getenv("tc_root"); //ȡtc_root·==C:\Siemens\Teamcenter11 + char jar_file[SS_MAXPATHLEN] = ""; + strcpy(jar_file, tc_root_file); + strcat(jar_file, "\\portal\\plugins\\"); + strcat(jar_file, "JLCS_05.jar"); + + + //ȡ + EPM_ask_root_task(msg.task, &rootTask); + //ȡĿ + EPM_ask_attachments(rootTask, EPM_target_attachment, &attachments_num, &attachments); + //char *temp_dir = getenv("temp"); //C:\Windows\temp + + for (int i = 0; i < attachments_num; i++) + { + //ȡtopline + AOM_ask_value_string(attachments[i], "object_type", &object_type); + printf("object_type=%s \n", object_type); + //˵ǰ汾Ķ + if((strstr(object_type,"Revision") == NULL) || (strstr(object_type,"Master") != NULL) + || (strstr(object_type,"master") != NULL) || (strstr(object_type,"BOM") != NULL) || (strstr(object_type,"bom") != NULL) || (strstr(object_type,"Bom") != NULL)) + { + continue; + } + + char * puid = NULL; + //ȡPUID + ITK__convert_tag_to_uid(attachments[i], &puid); + + //strcat(parameters, puid); + //strcat(parameters, "}}"); + + printf("object_type2=%s \n", object_type); + //if (strcmp("ItemRevision", object_type) == 0) { + + ITEM_rev_list_bom_view_revs(attachments[i], &bvr_count, &bvr_list); + //printf("ͼ=%d \n", bvr_count); + + if (bvr_count == 0) { + continue; + } + // + BOM_create_window(&bom_window_tag); + BOM_set_window_top_line_bvr(bom_window_tag, bvr_list[bvr_count - 1], &top_line); + //BOM_ask_window_top_line(bom_window_tag, &top_line); + + printf("parameters1:\n%s\n", parameters); + //getBomLinePropertys(top_line,puid); + BOM_line_ask_all_child_lines(top_line, &count, &children_line); + for (int ii = 0; ii < count; ii++) + { + char * object_type = NULL; + //ȡ汾 + tag_t partItemRevision = NULLTAG, parentItemRevision = NULLTAG; + AOM_ask_value_tag(children_line[ii],"bl_line_object",&partItemRevision); + AOM_ask_value_tag(top_line,"bl_line_object",&parentItemRevision); + //ITKCALL(ITEM_ask_latest_rev(partItem,&partItemRevision)); + + AOM_ask_value_string(partItemRevision, "object_type", &object_type); + //˷汾Ķ + if (strcmp("Gd6_PartsRevision", object_type) == 0 + || strcmp("Gd6_BZJRevision", object_type) == 0|| strcmp("Gd6_XZMKCRevision", object_type) == 0) { + int item_mast_rev_count = 0; + tag_t * item_mast_rev = NULLTAG; + //ȡ汾 + ITKCALL(AOM_ask_value_tags(partItemRevision, "IMAN_master_form_rev", &item_mast_rev_count, &item_mast_rev ) ) + + //ȡtopline + // + AOM_ask_value_string(parentItemRevision, "item_id", &MATNR); + // + WERKS = "6300"; + //AOM_ask_value_string(children_line[ii], "bl_formatted_parent_name", &bl_formatted_parent_name); + //BOM; + STLAN = "1"; + //ѡBOM + STALT = "1"; + //۵ + VBELN = ""; + //Ŀ + VBPOS = ""; + // + AOM_ask_value_string(top_line, "bl_quantity", &BMENG); + //BOMĿ + AOM_ask_value_string(children_line[ii], "bl_sequence_no", &POSNR); + //Ŀ + POSTP = "L"; + //Ӽ + AOM_ask_value_string(partItemRevision, "item_id", &IDNRK); + //Ӽ + AOM_ask_value_string(children_line[ii], "bl_quantity", &MENGE); + //Ӽλ + AOM_ask_value_string(item_mast_rev[0], "gd6_dw", &MEINS); + // + AOM_ask_value_string(children_line[0], "Gd6_psqy", &POTX1); + //λ/͹λgd6_scgw&gd6_psgw + char * scgw = NULL, * psgw = NULL; + + AOM_ask_value_string(children_line[0], "Gd6_scgw", &scgw); + AOM_ask_value_string(children_line[0], "Gd6_psgw", &psgw); + + strcat(parameters, MATNR); + strcat(parameters, ","); + strcat(parameters, WERKS); + strcat(parameters, ","); + strcat(parameters, STLAN); + strcat(parameters, ","); + strcat(parameters, STALT); + strcat(parameters, ","); + strcat(parameters, VBELN); + strcat(parameters, ","); + strcat(parameters, VBPOS); + strcat(parameters, ","); + strcat(parameters, BMENG); + strcat(parameters, ","); + strcat(parameters, POSNR); + strcat(parameters, ","); + strcat(parameters, POSTP); + strcat(parameters, ","); + strcat(parameters, IDNRK); + strcat(parameters, ","); + strcat(parameters, MENGE); + strcat(parameters, ","); + strcat(parameters, MEINS); + strcat(parameters, ","); + strcat(parameters, POTX1); + strcat(parameters, ","); + strcat(parameters, scgw); + strcat(parameters, ","); + strcat(parameters, psgw); + strcat(parameters, ","); + strcat(parameters, puid); + strcat(parameters, "}}"); + //strcat(parameters, parameter); + printf("parameter:\n%s\n", parameters); + //strcat(parameters, C5_gc); + //strcat(parameters, C5_scgw); + + + + //char cmd[256] = ""; + //strcpy(cmd, "java -jar \""); + //strcat(cmd, jar_file); + //strcat(cmd, "\" "); + // + //strcat(cmd, parameter); + //printf("·:\n%s\n", cmd); + //system(cmd); + //countNum++; + } + } + //DOFREE(puid) + + //char *strResult = (char*)malloc((strlen(parameters) + 512) * sizeof(int));; + //string strResult; + /*while (fgets(buf, sizeof buf, pf) != NULL) { + printf("%s", buf); + EMH_store_error_s1( EMH_severity_user_error, EMH_USER_error_base,buf); + ifail = 1; + }*/ + + //} + } + + //дļ + char data_file[SS_MAXPATHLEN] = ""; + strcat(data_file,tc_root_file); + strcat(data_file,"\\single_bom.txt"); + FILE* fptr; + fptr = fopen(data_file, "w"); + fprintf(fptr, "%s", parameters); + fclose(fptr); + + char *cmd = (char*)malloc(512 * sizeof(int)); + strcpy(cmd, "java -jar \""); + strcat(cmd, jar_file); + strcat(cmd, "\" "); + // + strcat(cmd, data_file); + strcat(cmd,"getBomPropertys"); + printf("·:\n%s\n", cmd); + char buf[64] = {0}; + FILE *pf = NULL; + if ((pf = _popen(cmd, "r")) == NULL) { + printf("ӿڷ:\n%s", "1"); + } + string strResult; + while (fgets(buf, sizeof buf, pf)) { + strResult += buf; + } + _pclose(pf); + unsigned int iSize = strResult.size(); + if (iSize > 0 && strResult[iSize - 1] == '\n') + { + strResult = strResult.substr(0, iSize - 1); + //ȡҵ + tag_t job = NULLTAG; + + EPM_ask_job(rootTask,&job); + + POM_AM__set_application_bypass(true); + //ֵ + //lock + AOM_lock(job); + //set + AOM_set_value_string(job,"object_desc",strResult.c_str()); + //save + AOM_save( job ) ; + //unlock + AOM_unlock( job ) ; + AOM_refresh( job,FALSE ); + POM_AM__set_application_bypass(false); + //EMH_store_error_s1( EMH_severity_user_error, EMH_USER_error_base,strResult.c_str()); + //ifail = 1; + } + //system(cmd); + BOM_close_window(bom_window_tag); + DOFREE(bvr_list); + parameters = NULL; + cmd = NULL; + + + + DOFREE(attachments); + tc_root_file = NULL; + DOFREE(children_line); + DOFREE(MATNR); + WERKS = NULL; + STLAN = NULL; + STALT = NULL; + VBELN = NULL; + VBPOS = NULL; + BMENG = NULL; + DOFREE(POSNR); + POSTP = NULL; + DOFREE(IDNRK); + DOFREE(MENGE); + DOFREE(MEINS); + DOFREE(POTX1); + DOFREE(POTX2); + printf("ִн\n"); + + return ifail; +} + +int JLCS_05_BOMSendOutSap(EPM_action_message_t msg) +{ + printf("ʼִ\n"); + int ifail = ITK_ok; + + parameters = (char*)malloc(512 * sizeof(char)); + strcpy(parameters, "getBomPropertys}}"); + //parameters = "getBomPropertys}}"; + printf("parameters1:\n%s\n", parameters); + int attachments_num; + int bvr_count; + tag_t rootTask = NULLTAG, *attachments = NULLTAG, top_line = NULLTAG, *children_line = NULLTAG, *bvr_list = NULLTAG; + tag_t bom_window_tag; + char *object_type = NULL; + int count; + + char *tc_root_file = getenv("tc_root"); //ȡtc_root·==C:\Siemens\Teamcenter11 + char jar_file[SS_MAXPATHLEN] = ""; + strcpy(jar_file, tc_root_file); + strcat(jar_file, "\\portal\\plugins\\"); + strcat(jar_file, "JLCS_05.jar"); + + + //ȡ + EPM_ask_root_task(msg.task, &rootTask); + //ȡĿ + EPM_ask_attachments(rootTask, EPM_target_attachment, &attachments_num, &attachments); + //char *temp_dir = getenv("temp"); //C:\Windows\temp + + for (int i = 0; i < attachments_num; i++) + { + //ȡtopline + AOM_ask_value_string(attachments[i], "object_type", &object_type); + printf("object_type=%s \n", object_type); + //˵ǰ汾Ķ + if((strstr(object_type,"Revision") == NULL) || (strstr(object_type,"Master") != NULL) + || (strstr(object_type,"master") != NULL) || (strstr(object_type,"BOM") != NULL) || (strstr(object_type,"bom") != NULL) || (strstr(object_type,"Bom") != NULL)) + { + continue; + } + + char * puid = NULL; + //ȡPUID + ITK__convert_tag_to_uid(attachments[i], &puid); + + strcat(parameters, puid); + strcat(parameters, "}}"); + + printf("object_type2=%s \n", object_type); + //if (strcmp("ItemRevision", object_type) == 0) { + + ITEM_rev_list_bom_view_revs(attachments[i], &bvr_count, &bvr_list); + //printf("ͼ=%d \n", bvr_count); + + if (bvr_count == 0) { + continue; + } + // + BOM_create_window(&bom_window_tag); + BOM_set_window_top_line_bvr(bom_window_tag, bvr_list[bvr_count - 1], &top_line); + //BOM_ask_window_top_line(bom_window_tag, &top_line); + + printf("parameters1:\n%s\n", parameters); + getBomLinePropertys(top_line,NULL); + + char *cmd = (char*)malloc((strlen(parameters) + 512) * sizeof(int)); + strcpy(cmd, "java -jar \""); + strcat(cmd, jar_file); + strcat(cmd, "\" "); + // + strcat(cmd, parameters); + //printf("·:\n%s\n", cmd); + char buf[64] = {0}; + FILE *pf = NULL; + if ((pf = _popen(cmd, "r")) == NULL) { + printf("ӿڷ:\n%s", "1"); + } + string strResult; + while (fgets(buf, sizeof buf, pf)) { + strResult += buf; + } + _pclose(pf); + unsigned int iSize = strResult.size(); + if (iSize > 0 && strResult[iSize - 1] == '\n') + { + strResult = strResult.substr(0, iSize - 1); + //ȡҵ + tag_t job = NULLTAG; + + EPM_ask_job(rootTask,&job); + + POM_AM__set_application_bypass(true); + //ֵ + //lock + AOM_lock(job); + //set + AOM_set_value_string(job,"object_desc",strResult.c_str()); + //save + AOM_save( job ) ; + //unlock + AOM_unlock( job ) ; + AOM_refresh( job,FALSE ); + POM_AM__set_application_bypass(false); + //EMH_store_error_s1( EMH_severity_user_error, EMH_USER_error_base,strResult.c_str()); + //ifail = 1; + } + + //char *strResult = (char*)malloc((strlen(parameters) + 512) * sizeof(int));; + //string strResult; + /*while (fgets(buf, sizeof buf, pf) != NULL) { + printf("%s", buf); + EMH_store_error_s1( EMH_severity_user_error, EMH_USER_error_base,buf); + ifail = 1; + }*/ + _pclose(pf); + //system(cmd); + BOM_close_window(bom_window_tag); + DOFREE(bvr_list); + parameters = NULL; + cmd = NULL; + DOFREE(puid) + //} + } + DOFREE(attachments); + tc_root_file = NULL; + DOFREE(children_line); + DOFREE(MATNR); + WERKS = NULL; + STLAN = NULL; + STALT = NULL; + VBELN = NULL; + VBPOS = NULL; + BMENG = NULL; + DOFREE(POSNR); + POSTP = NULL; + DOFREE(IDNRK); + DOFREE(MENGE); + DOFREE(MEINS); + DOFREE(POTX1); + DOFREE(POTX2); + printf("ִн\n"); + + return ifail; +} +int Super_Bom_Appent_Data (void *returnValue) +{ + printf("=========================ͬBOM START ===================\n"); + countInsertSql = 0; + ::CoInitialize(NULL); //ʼOLE/COM⻷ + HRESULT hr = NULL; + _ConnectionPtr m_pConnection; // ݿ + _RecordsetPtr m_pRecordset; // + _CommandPtr m_pCommand; // ¼ + + int valueNum=0; + + char* server_address; + + PREF_ask_char_value("TC11_SqlServer_Link_ITK", valueNum, &server_address); + + char *object_type = NULL, * carModel = NULL; + int bvr_count; + tag_t * bvr_list = NULLTAG,bom_window_tag = NULLTAG, top_line = NULLTAG; + tag_t itemRevision = NULLTAG; + + ITKCALL(USERARG_get_tag_argument(&itemRevision)); + //char *people = NULL; + //USERARG_get_string_argument(&people); + + //ȡtopline + AOM_ask_value_string(itemRevision, "object_type", &object_type); + AOM_ask_value_string(itemRevision, "item_id", &carModel); + printf("object_type=%s \n", object_type); + printf("item_id=%s \n", carModel); + + ITEM_rev_list_bom_view_revs(itemRevision, &bvr_count, &bvr_list); + if (bvr_count == 0) { + return 0; + } + hr = m_pConnection.CreateInstance(_uuidof(Connection));//Ӷʵ + if (SUCCEEDED(hr)) + { + /* + Provider=SQLOLEDB.1 ------ݿoledbķʽbai + Persist Security Info ----Ƿ񱣴氲ȫϢdu + User ID-------------------û + PassWord------------------zhi + Initial Catalog-----------ݿƻݿipĿdao¼ + Data Source---------------Դ + */ + m_pConnection->ConnectionString = (server_address); + //printf("\n==========================================================\n"); + hr = m_pConnection->Open("", "", "", adConnectUnspecified);//ݿ + if (FAILED(hr)) + { + printf("Open Failed!"); + return 1; + } + else + { + //m_pRecordset->Open("","", adOpenKeyset,adLockOptimistic,adCmdText); + //long RecordCount; + //RecordCount=m_pRecordset->Fields->GetItem((long)0)->GetValue(); + //޸Ϊ(ھ) + long sumrows = 0; + char* selectLable = (char*)calloc(1024, sizeof(char)); + sprintf(selectLable,"select count(*) from GD_ORDERBOM_LABLE where ItemID = '%s'",carModel); + m_pRecordset = m_pConnection->Execute(_bstr_t(selectLable), 0, adCmdText); + /*sumrows = m_pRecordset->GetRecordCount();*/ + _variant_t vIndex = (long)0; + _variant_t vCount = m_pRecordset->GetCollect(vIndex); + printf("%d¼",vCount.lVal); + sumrows = vCount.lVal; + m_pRecordset->Close(); + printf("end =%ld\n",sumrows); + if(sumrows > 0){ + //ڣ޸ģ + char* updateLable = (char*)calloc(1024, sizeof(char)); + sprintf(updateLable, "update GD_ORDERBOM_LABLE set Lable = '' where ItemID = '%s'", carModel); + m_pConnection->Execute(_bstr_t(updateLable), 0, adCmdText); + updateLable = NULL; + } + else{ + //ڣ + char* insertLable = (char*)calloc(1024, sizeof(char)); + sprintf(insertLable, "insert into GD_ORDERBOM_LABLE(ItemID,Lable) values('%s','') ", carModel); + m_pConnection->Execute(_bstr_t(insertLable), 0, adCmdText); + insertLable = NULL; + } + selectLable = NULL; + + //ɾLableеһУӡ + //char* deleteLable = (char*)calloc(1024, sizeof(char)); + //sprintf(deleteLable, "delete from GD_ORDERBOM_LABLE where ItemID = '%s'", carModel); + //m_pConnection->Execute(_bstr_t(deleteLable), 0, adCmdText); + //deleteLable = NULL; + //char* insertLable = (char*)calloc(1024, sizeof(char)); + //sprintf(insertLable, "insert into GD_ORDERBOM_LABLE(ItemID,Lable) values('%s','') ", carModel); + //m_pConnection->Execute(_bstr_t(insertLable), 0, adCmdText); + //insertLable = NULL; + + //ɾݿ + char* deleteSql = (char*)calloc(1024, sizeof(char)); + tag_t partItemRevision = NULLTAG,item = NULLTAG; + sprintf(deleteSql, "delete from GD_ORDERBOM_DATA where carModel = '%s'", carModel); + + m_pConnection->Execute(_bstr_t(deleteSql), 0, adCmdText); + //printf("ɾɹ\n"); + //gd6_psgw + // + BOM_create_window(&bom_window_tag); + BOM_set_window_top_line_bvr(bom_window_tag, bvr_list[bvr_count - 1], &top_line); + + string childUUID = carModel; + char * itemId = ""; + char * formula = ""; + char * itemType = ""; + char * sequenceNumber = ""; + char * hierarchy = ""; + char * quantity = ""; + char * psqy = ""; + char * scqy = ""; + char * psqw = ""; + char * scgw = ""; + char * name = ""; + char * sjzl = ""; + char * mz = ""; + char * wlfl = ""; + char * dw = ""; + char * jcjwlh = ""; + char * sfqdj = ""; + char * gyzy = ""; + char * clgg = ""; + char * clhd = ""; + + AOM_ask_value_tag(top_line,"bl_line_object",&partItemRevision); + ITEM_ask_item_of_rev( partItemRevision, &item); + AOM_ask_value_string(item, "object_type", &itemType); + AOM_ask_value_string(top_line, "bl_sequence_no", &sequenceNumber); + AOM_ask_value_string(top_line, "bl_item_item_id", &itemId); + AOM_ask_value_string(top_line, "bl_formula", &formula); + //AOM_ask_value_string(children_line[ii], "bl_level_starting_0", &POTX1); + AOM_ask_value_string(top_line, "bl_quantity", &quantity); + AOM_ask_value_string(top_line, "Gd6_psqy", &psqy); + AOM_ask_value_string(top_line, "Gd6_scqy", &scqy); + AOM_ask_value_string(top_line, "Gd6_psgw", &psqw); + AOM_ask_value_string(top_line, "Gd6_scgw", &scgw); + AOM_ask_value_string(top_line, "bl_item_object_name", &name); + AOM_ask_value_string(top_line, "bl_Gd6_PartsRevisionMaster_gd6_sjzl", &sjzl); + AOM_ask_value_string(top_line, "bl_Gd6_PartsRevisionMaster_gd6_mz", &mz); + AOM_ask_value_string(top_line, "bl_Gd6_PartsRevisionMaster_gd6_wlfl", &wlfl); + AOM_ask_value_string(top_line, "bl_Gd6_PartsRevisionMaster_gd6_dw", &dw); + AOM_ask_value_string(top_line, "bl_Gd6_PartsRevisionMaster_gd6_jcjwlh", &jcjwlh); + AOM_ask_value_string(top_line, "bl_Gd6_PartsRevisionMaster_gd6_sfqdj", &sfqdj); + AOM_ask_value_string(top_line, "bl_Gd6_PartsRevisionMaster_gd6_gyzy", &gyzy); + AOM_ask_value_string(top_line, "bl_Gd6_PartsRevisionMaster_gd6_clgg", &clgg); + AOM_ask_value_string(top_line, "bl_Gd6_PartsRevisionMaster_gd6_clhd", &clhd); + + char* insertSql = (char*)calloc(1024, sizeof(char)); + sprintf(insertSql, "INSERT INTO GD_ORDERBOM_DATA (carModel,parentID,id,bl_formula,bl_item_type,bl_sequence_no,uid,hierarchy,bl_quantity,psqy,scqy,psgw,scgw,bl_item_object_name,sjzl,mz,wlfl,dw,jcjwlh,sfqdj,gyzy,realParentID,clgg,clhd) VALUES ('%s','%s','%s','%s','%s','%s','%s','%s','%s','%s','%s','%s','%s','%s','%s','%s','%s','%s','%s','%s','%s','%s','%s','%s')",carModel,"",itemId,formula,itemType,sequenceNumber,childUUID.c_str(),hierarchy,quantity,psqy,scqy,psqw,scgw,name,sjzl,mz,wlfl,dw,jcjwlh,sfqdj,gyzy,"",clgg,clhd); + + m_pConnection->Execute(_bstr_t(insertSql), 0, adCmdText); + countInsertSql++; + deleteSql = NULL; + DOFREE(itemId); + DOFREE(formula); + DOFREE(itemType); + DOFREE(sequenceNumber); + hierarchy = NULL; + DOFREE(quantity); + DOFREE(psqy); + DOFREE(scqy); + DOFREE(psqw); + DOFREE(scgw); + DOFREE(name); + DOFREE(sjzl); + DOFREE(mz); + DOFREE(wlfl); + DOFREE(dw); + DOFREE(jcjwlh); + DOFREE(sfqdj); + DOFREE(gyzy); + DOFREE(clgg); + DOFREE(clhd); + insertSql = NULL; + try{ + getBomLinePropertysBom(top_line,carModel,carModel,m_pConnection); + //жĿǷһ + long sqlCount = 0; + char* selectCount = (char*)calloc(1024, sizeof(char)); + sprintf(selectCount,"select count(*) from GD_ORDERBOM_DATA where carModel = '%s'",carModel); + m_pRecordset = m_pConnection->Execute(_bstr_t(selectCount), 0, adCmdText); + /*sumrows = m_pRecordset->GetRecordCount();*/ + _variant_t vIndexCount = (long)0; + _variant_t vCountCount = m_pRecordset->GetCollect(vIndexCount); + printf("%d¼\n",countInsertSql); + printf("ݿ%d¼\n",vCountCount.lVal); + sqlCount = vCountCount.lVal; + m_pRecordset->Close(); + if(sqlCount == countInsertSql){ + //޸ijBOM״̬(ɹ) + char* updateSql = (char*)calloc(1024, sizeof(char)); + sprintf(updateSql, "update GD_ORDERBOM_LABLE set Lable = '³ɹ',Remark = '' where ItemID = '%s'", carModel); + m_pConnection->Execute(_bstr_t(updateSql), 0, adCmdText); + updateSql = NULL; + } + else{ + //޸ijBOM״̬(ʧ) + char* updateSql = (char*)calloc(1024, sizeof(char)); + sprintf(updateSql, "update GD_ORDERBOM_LABLE set Lable = 'ʧ',Remark = 'Ŀһ' where ItemID = '%s'", carModel); + m_pConnection->Execute(_bstr_t(updateSql), 0, adCmdText); + updateSql = NULL; + } + + //־ + //char *insertLog = (char*)calloc(1024, sizeof(char)); + //sprintf(insertLog, "insert into GD_ORDERBOM_LABLE_LOG(ItemID,Lable) VALUES('%s','³ɹ')",carModel); + //m_pConnection->Execute(_bstr_t(insertLog), 0, adCmdText); + //insertLog = NULL; + } + catch(exception e ){ + //ʧԭ + char* updateSql = (char*)calloc(1024, sizeof(char)); + sprintf(updateSql, "update GD_ORDERBOM_LABLE set Lable = 'ʧ'Remark = '%s' where ItemID = '%s'",e.what() ,carModel); + m_pConnection->Execute(_bstr_t(updateSql), 0, adCmdText); + updateSql = NULL; + //־ + //char *insertLog = (char*)calloc(1024, sizeof(char)); + //sprintf(insertLog, "insert into GD_ORDERBOM_LABLE_LOG(ItemID,Lable,Remark) VALUES('%s','ʧ','%s')",carModel,e.what() ); + //m_pConnection->Execute(_bstr_t(insertLog), 0, adCmdText); + //insertLog = NULL; + std::cout << e.what() << std::endl; + } + + } + } + else + { + printf("Create instance of connection failed!"); + return 1; + } + + DOFREE(object_type); + DOFREE(server_address); + DOFREE(carModel); + DOFREE(bvr_list); + printf("=========================ͬBOM END ===================\n"); + return 0; +} + +void getBomLinePropertysBom(tag_t top_line,string topUUID,char * carModel, _ConnectionPtr m_pConnection) { + //printf("ʼִgetBomLinePropertys\n"); + int count; + tag_t *children_line; + ITKCALL(BOM_line_ask_all_child_lines(top_line, &count, &children_line)); + //printf("=%d \n", count); + for (int ii = 0; ii < count; ii++) + { + countInsertSql++; + tag_t partItemRevision = NULLTAG,item = NULLTAG; + + + string childUUID = getUUid(); + char * itemId = ""; + char * formula = ""; + char * itemType = ""; + char * sequenceNumber = ""; + char * hierarchy = ""; + char * quantity = ""; + char * psqy = ""; + char * scqy = ""; + char * psqw = ""; + char * scgw = ""; + char * name = ""; + char * sjzl = ""; + char * mz = ""; + char * wlfl = ""; + char * dw = ""; + char * jcjwlh = ""; + char * sfqdj = ""; + char * gyzy = ""; + char * realParentID = ""; + char * clgg = ""; + char * clhd = ""; + ITKCALL(AOM_ask_value_string(top_line,"bl_item_item_id",&realParentID)); + ITKCALL(AOM_ask_value_tag(children_line[ii],"bl_line_object",&partItemRevision)); + ITKCALL(ITEM_ask_item_of_rev( partItemRevision, &item)); + ITKCALL(AOM_ask_value_string(item, "object_type", &itemType)); + ITKCALL(AOM_ask_value_string(children_line[ii], "bl_sequence_no", &sequenceNumber)); + ITKCALL(AOM_ask_value_string(children_line[ii], "bl_item_item_id", &itemId)); + ITKCALL(AOM_ask_value_string(children_line[ii], "bl_formula", &formula)); + ITKCALL(AOM_ask_value_string(children_line[ii], "bl_quantity", &quantity)); + ITKCALL(AOM_ask_value_string(children_line[ii], "Gd6_psqy", &psqy)); + ITKCALL(AOM_ask_value_string(children_line[ii], "Gd6_scqy", &scqy)); + ITKCALL(AOM_ask_value_string(children_line[ii], "Gd6_psgw", &psqw)); + ITKCALL(AOM_ask_value_string(children_line[ii], "Gd6_scgw", &scgw)); + ITKCALL(AOM_ask_value_string(children_line[ii], "bl_item_object_name", &name)); + ITKCALL(AOM_ask_value_string(children_line[ii], "bl_Gd6_PartsRevisionMaster_gd6_sjzl", &sjzl)); + ITKCALL(AOM_ask_value_string(children_line[ii], "bl_Gd6_PartsRevisionMaster_gd6_mz", &mz)); + ITKCALL(AOM_ask_value_string(children_line[ii], "bl_Gd6_PartsRevisionMaster_gd6_wlfl", &wlfl)); + ITKCALL(AOM_ask_value_string(children_line[ii], "bl_Gd6_PartsRevisionMaster_gd6_dw", &dw)); + ITKCALL(AOM_ask_value_string(children_line[ii], "bl_Gd6_PartsRevisionMaster_gd6_jcjwlh", &jcjwlh)); + ITKCALL(AOM_ask_value_string(children_line[ii], "bl_Gd6_PartsRevisionMaster_gd6_sfqdj", &sfqdj)); + ITKCALL(AOM_ask_value_string(children_line[ii], "bl_Gd6_PartsRevisionMaster_gd6_gyzy", &gyzy)); + ITKCALL(AOM_ask_value_string(children_line[ii], "bl_Gd6_PartsRevisionMaster_gd6_clgg", &clgg)); + ITKCALL(AOM_ask_value_string(children_line[ii], "bl_Gd6_PartsRevisionMaster_gd6_clhd", &clhd)); + char* insertSql = (char*)calloc(2048, sizeof(char)); + sprintf(insertSql, "INSERT INTO GD_ORDERBOM_DATA (carModel,parentID,id,bl_formula,bl_item_type,bl_sequence_no,uid,hierarchy,bl_quantity,psqy,scqy,psgw,scgw,bl_item_object_name,sjzl,mz,wlfl,dw,jcjwlh,sfqdj,gyzy,realParentID,clgg,clhd) VALUES ('%s','%s','%s','%s','%s','%s','%s','%s','%s','%s','%s','%s','%s','%s','%s','%s','%s','%s','%s','%s','%s','%s','%s','%s')",carModel,topUUID.c_str(),itemId,formula,itemType,sequenceNumber,childUUID.c_str(),hierarchy,quantity,psqy,scqy,psqw,scgw,name,sjzl,mz,wlfl,dw,jcjwlh,sfqdj,gyzy,realParentID,clgg,clhd); + //printf("sql%s\n",insertSql); + m_pConnection->Execute(_bstr_t(insertSql), 0, adCmdText); + DOFREE(itemId); + DOFREE(formula); + DOFREE(itemType); + DOFREE(sequenceNumber); + hierarchy = NULL; + DOFREE(quantity); + DOFREE(psqy); + DOFREE(scqy); + DOFREE(psqw); + DOFREE(scgw); + DOFREE(name); + DOFREE(sjzl); + DOFREE(mz); + DOFREE(wlfl); + DOFREE(dw); + DOFREE(jcjwlh); + DOFREE(sfqdj); + DOFREE(gyzy); + DOFREE(realParentID); + DOFREE(clgg); + DOFREE(clhd); + insertSql = NULL; + + getBomLinePropertysBom(children_line[ii],childUUID,carModel,m_pConnection); + } + + DOFREE(children_line); + +} +//void getBomPropertys(EPM_action_message_t msg, int ifail) { +// +// +// +// +//} + + +void getBomLinePropertys(tag_t top_line,char *type) { + //printf("ʼִgetBomLinePropertys\n"); + int count; + tag_t *children_line; + parameters = (char *)realloc(parameters, (countNum * 512) * sizeof(char)); + //char parameter[5120] = "getBomPropertys,"; + + + + char *tc_root_file = getenv("tc_root"); //C:\Siemens\Teamcenter11 + char jar_file[SS_MAXPATHLEN] = ""; + strcpy(jar_file, tc_root_file); + strcat(jar_file, "\\portal\\plugins\\"); + strcat(jar_file, "JLCS_05.jar"); + + BOM_line_ask_all_child_lines(top_line, &count, &children_line); + printf("=%d \n", count); + for (int ii = 0; ii < count; ii++) + { + char * object_type = NULL; + //ȡ汾 + tag_t partItemRevision = NULLTAG, parentItemRevision = NULLTAG; + AOM_ask_value_tag(children_line[ii],"bl_line_object",&partItemRevision); + AOM_ask_value_tag(top_line,"bl_line_object",&parentItemRevision); + //ITKCALL(ITEM_ask_latest_rev(partItem,&partItemRevision)); + + AOM_ask_value_string(partItemRevision, "object_type", &object_type); + //˷汾Ķ + if (strcmp("Gd6_PartsRevision", object_type) == 0 + || strcmp("Gd6_BZJRevision", object_type) == 0|| strcmp("Gd6_XZMKCRevision", object_type) == 0) { + int item_mast_rev_count = 0; + tag_t * item_mast_rev = NULLTAG; + //ȡ汾 + ITKCALL(AOM_ask_value_tags(partItemRevision, "IMAN_master_form_rev", &item_mast_rev_count, &item_mast_rev ) ) + char * wlfl = NULL; + AOM_ask_value_string(item_mast_rev[0], "gd6_wlfl", &wlfl); + if(strcmp("H40", wlfl) == 0){ + continue; + } + //ȡtopline + // + AOM_ask_value_string(parentItemRevision, "item_id", &MATNR); + // + WERKS = "6300"; + //AOM_ask_value_string(children_line[ii], "bl_formatted_parent_name", &bl_formatted_parent_name); + //BOM; + STLAN = "1"; + //ѡBOM + STALT = "1"; + //۵ + VBELN = ""; + //Ŀ + VBPOS = ""; + // + AOM_ask_value_string(top_line, "bl_quantity", &BMENG); + //BOMĿ + AOM_ask_value_string(children_line[ii], "bl_sequence_no", &POSNR); + //Ŀ + POSTP = "L"; + //Ӽ + AOM_ask_value_string(partItemRevision, "item_id", &IDNRK); + //Ӽ + AOM_ask_value_string(children_line[ii], "bl_quantity", &MENGE); + //Ӽλ + AOM_ask_value_string(item_mast_rev[0], "gd6_dw", &MEINS); + // + AOM_ask_value_string(children_line[0], "Gd6_psqy", &POTX1); + //λ/͹λgd6_scgw&gd6_psgw + char * scgw = NULL, * psgw = NULL; + + AOM_ask_value_string(children_line[0], "Gd6_scgw", &scgw); + AOM_ask_value_string(children_line[0], "Gd6_psgw", &psgw); + + strcat(parameters, MATNR); + strcat(parameters, ","); + strcat(parameters, WERKS); + strcat(parameters, ","); + strcat(parameters, STLAN); + strcat(parameters, ","); + strcat(parameters, STALT); + strcat(parameters, ","); + strcat(parameters, VBELN); + strcat(parameters, ","); + strcat(parameters, VBPOS); + strcat(parameters, ","); + strcat(parameters, BMENG); + strcat(parameters, ","); + strcat(parameters, POSNR); + strcat(parameters, ","); + strcat(parameters, POSTP); + strcat(parameters, ","); + strcat(parameters, IDNRK); + strcat(parameters, ","); + strcat(parameters, MENGE); + strcat(parameters, ","); + strcat(parameters, MEINS); + strcat(parameters, ","); + strcat(parameters, POTX1); + strcat(parameters, ","); + strcat(parameters, scgw); + strcat(parameters, ","); + strcat(parameters, psgw); + strcat(parameters, ","); + strcat(parameters, type); + strcat(parameters, "}}"); + //strcat(parameters, parameter); + printf("parameter:\n%s\n", parameters); + //strcat(parameters, C5_gc); + //strcat(parameters, C5_scgw); + + + + //char cmd[256] = ""; + //strcpy(cmd, "java -jar \""); + //strcat(cmd, jar_file); + //strcat(cmd, "\" "); + // + //strcat(cmd, parameter); + //printf("·:\n%s\n", cmd); + //system(cmd); + countNum++; + } + if(type == NULL){ + getBomLinePropertys(children_line[ii],type); + } + + } + +} + + +//--------------------------------------------------------------------------------------------------------- + +//ַָ +void split(char *src, const char *separator, char **dest, int *num) { + /* + src Դַ׵ַ(bufĵַ) + separator ָķַָ + dest ַ + num ַָĸ + */ + char *pNext; + int count = 0; + if (src == NULL || strlen(src) == 0) //ĵַΪջ򳤶Ϊ0ֱֹ + return; + if (separator == NULL || strlen(separator) == 0) //δֱַָָֹ + return; + + + printf("ָǰַ=======================%s\n",src); + + pNext = strtok(src, separator); //ʹ(char *)ǿת(Ȼдеıвָ) + while (pNext != NULL) { + + + printf("ַָ=======================%s\n",pNext); + + dest[count] = pNext; + ++count; + pNext = strtok(NULL, separator); //ʹ(char *)ǿת + } + *num = count; +} diff --git a/CONNOR_ITK/JLCS_05_MasterData.cxx b/CONNOR_ITK/JLCS_05_MasterData.cxx new file mode 100644 index 0000000..4bf2642 --- /dev/null +++ b/CONNOR_ITK/JLCS_05_MasterData.cxx @@ -0,0 +1,1206 @@ +#define _CRT_SECURE_NO_WARNINGS +#include "epm_handler_common.h" + +#include +#include + +#include + +#include +#include + +#include +#include +#include +#include +#pragma warning(disable : 4996) +#include +#include +#include +#include "common_itk_util.h" +extern "C" int POM_AM__set_application_bypass(logical bypass); + + +using namespace std; + + + + +//char *bl_indented_title, *bl_formatted_parent_name, *bl_quantity, *bl_uom, *Gd6_gc, *Gd6_bomyt, *Gd6_kxbom, *Gd6_xsdh, *Gd6_ddxmhh, *Gd6_ddsl, *Gd6_bomxmh, *Gd6_xmlb, *Gd6_psgw, *Gd6_scgw; +// +void getBomMasterDataPropertys(EPM_action_message_t msg, int valueNum, char **server_address, int bl_item_id_num); +void getBomLineItemPropertys(tag_t top_line,int bl_item_id_num); + + +int JLCS_05_BOMSendOutSap_MasterData(EPM_action_message_t msg) +{ + char* log_file = NULL; + char log_path[128] = "C:\\Temp\\JLCS_05_BOMSendOutSap_MasterData_LOG.txt"; + CreateLogFile(log_path, &log_file); + + printf("ʼִϴݵSAP\n"); + WriteLog("ʼִϴݵSAP\n"); + //POM_AM__set_application_bypass(true); + int ifail = ITK_ok; + int valueNum; + char **server_address; + //printf("ʼȡѡ\n"); + + int attachments_num=0; + int bvr_count; + tag_t rootTask, *attachments, *bvr_list = NULLTAG; + tag_t bom_window_tag = NULLTAG; + char *object_type; + int count; + tag_t item_rev; + + + char *item_rev_value = NULL; + + char *tc_root_file = getenv("tc_root"); //C:\Siemens\Teamcenter11 + char jar_file[SS_MAXPATHLEN] = ""; + + + + WriteLog("ʾʼȡµĸ\n"); + //ȡ + EPM_ask_root_task(msg.task, &rootTask); + //ȡĿ + WriteLog("ʾʼȡĿµĶ \n"); + EPM_ask_attachments(rootTask, EPM_target_attachment, &attachments_num, &attachments); + //char *temp_dir = getenv("temp"); //C:\Windows\temp + + char parameters[100000] = ""; + + char *handler_name; + AOM_ask_value_string(rootTask,"job_name",&handler_name); + WriteLog("ǰhandler_name=%s\n", handler_name); + WriteLog("ʾʼȡĿµĶ \n"); + for (int i = 0; i < attachments_num; i++) + { + + //ȡtopline + AOM_ask_value_string(attachments[i], "object_type", &object_type); + //printf("object_type=%s \n", object_type); + WriteLog("ȡ%sµĶobject_type=%s \n", handler_name,object_type); + + if (strcmp("Gd6_PartsRevision", object_type) == 0 || strcmp("Gd6_VehicleRevision", object_type) == 0 + || strcmp("Gd6_XZMKCRevision", object_type) == 0 || strcmp("Gd6_BZJRevision", object_type) == 0 + || strcmp("Gd6_PTJRevision", object_type) == 0) { + WriteLog("ʾǰĿµĶ in [Gd6_PartsRevision,Gd6_VehicleRevision,Gd6_XZMKCRevision,Gd6_BZJRevision,Gd6_PTJRevision] \n"); + //ITEM_rev_list_bom_view_revs(attachments[i], &bvr_count, &bvr_list); + //printf("ͼ=%d \n", bvr_count); + + //if (bvr_count == 0) { + // continue; + //} + //ȡBOM topline + //BOM_create_window(&bom_window_tag); + //BOM_set_window_top_line_bvr(bom_window_tag, bvr_list[bvr_count - 1], &top_line); + //BOM_ask_window_top_line(bom_window_tag, &top_line); + //printf("ʼȡ汾\n"); + char * puid = NULL; + //ȡPUID + ITK__convert_tag_to_uid(attachments[i], &puid); + WriteLog("ȡPUID==%s", puid); + + int item_mast_rev_count = 0; + tag_t *item_mast_rev NULLTAG; + + //ȡ汾 + ITKCALL(AOM_ask_value_tags(attachments[i], "IMAN_master_form_rev", &item_mast_rev_count, &item_mast_rev )); + WriteLog("ȡ汾=%d", item_mast_rev_count); + strcat(parameters, "getBomMasterDataPropertys}}"); + strcat(parameters, puid); + strcat(parameters, "}}"); + + //жǷѵ + //char * isSend = NULL; + //AOM_ask_value_string(item_mast_rev[0],"gd6_sfyxf", &isSend); + + //printf("Ƿѵ:%s\n", isSend); + + //if (strcmp("", isSend) == 0) + //{ + // PREF_ask_char_values("JL_BOMUpdateMasterData", &valueNum, &server_address);//ѡ + // strcpy(parameters,"updateBomMasterDataPropertys}}"); + + // strcat(parameters, puid); + // strcat(parameters, "}}"); + //} + //else + //{ + WriteLog("ʼȡѡJL_BOMSendSapMasterDataϢ\n"); + PREF_ask_char_values("JL_BOMSendSapMasterData", &valueNum, &server_address);//ѡ + //} + + + + + //BOM_line_ask_attribute_tag(top_line, bl_item_id_num, &item_rev);//ð汾 + + //printf("ʼѡ\n"); + WriteLog("ʼѡҪַָ\n"); + char *revbuf[8] = { 0 }; //ŷַָ + int num = 0;//ַָĸ + for (int ii = 0; ii < valueNum; ii++) { + //revbuf[8] = { 0 }; //ŷַָ + num = 0;//ַָĸ + split(server_address[ii], "/", revbuf, &num); + strcat(parameters, revbuf[0] == NULL || strlen(revbuf[0]) == 0 ? "": revbuf[0]); + strcat(parameters, "="); + WriteLog("ָserver_address[%d]=%sƴparameters=%s\n", ii, server_address[ii], parameters); + if(strstr(revbuf[1],"item_id") != NULL || strstr(revbuf[1],"object_name") != NULL) + { + WriteLog("%sֵаitem_idobject_name\n", revbuf[1]); + AOM_ask_value_string(attachments[i], revbuf[1], &item_rev_value); + } + else + { + WriteLog("%sֵвitem_idobject_name\n", revbuf[1]); + AOM_ask_value_string(item_mast_rev[0], revbuf[1], &item_rev_value); + } + + strcat(parameters, item_rev_value); + strcat(parameters, ""); + } + strcat(parameters, "@@"); + WriteLog("ƴparameters=%s\n", parameters); + //printf("parameters=====%s\n", parameters); + //printf("ӿڷֵ:%s\n", strResult.c_str()); + //system(cmd); + //getBomLineItemPropertys(top_line, bl_item_id_num); + MEM_free(bvr_list); + bvr_list = NULL; + MEM_free(object_type); + object_type = NULL; + //MEM_free(isSend); + //isSend = NULL; + MEM_free(puid); + puid = NULL; + } + } + + + strcpy(jar_file, tc_root_file); + strcat(jar_file, "\\portal\\plugins\\"); + strcat(jar_file, "JLCS_05.jar"); + + //дļ + WriteLog("ƴӵjar_file=%sʼдļ\n",jar_file); + char data_file[SS_MAXPATHLEN] = ""; + strcat(data_file,tc_root_file); + strcat(data_file,"\\data.txt"); + WriteLog("ƴdata_file=%s\n", data_file); + FILE* fptr; + fptr = fopen(data_file, "w"); + fprintf(fptr, "%s", parameters); + fclose(fptr); + WriteLog("дļ\n"); + string strResult; + + //cmdָ + WriteLog("ʼ֯cmdָ\n"); + char cmd[256] = ""; + strcpy(cmd, "java -jar \""); + //strcat(cmd, jar_file); + strcat(cmd,tc_root_file); + strcat(cmd,"\\portal\\plugins\\"); + strcat(cmd,"JLCS_05.jar"); + strcat(cmd, "\" "); + // + cout<0){ + // printf("ʼָ\n"); + // for(int i=0;i<=num/25;i++){ + // printf("һηָʼ\n"); + // char parameters2[8000] = ""; + // if(i==num/25){ + // for(int j = 25*i ; j < 25*i+num%25;j++){ + // strcat(parameters2,revbuf[j]); + // strcat(parameters2,"@@"); + // } + // } + // else{ + // for(int j=25*i;j <= 25*i+24;j++){ + // strcat(parameters2,revbuf[j]); + // strcat(parameters2,"@@"); + // } + // } + // //cmdָ + // char cmd[8000] = ""; + // strcpy(cmd, "java -jar \""); + // //strcpy(jar_file, tc_root_file); + // //strcat(jar_file, "\\portal\\plugins\\"); + // //strcat(jar_file, "JLCS_05.jar"); + // //strcat(cmd, jar_file); + // strcat(cmd,tc_root_file); + // strcat(cmd,"\\portal\\plugins\\"); + // strcat(cmd,"JLCS_05.jar"); + // strcat(cmd, "\" "); + // // + // cout< 0 && strResult[iSize - 1] == '\n' && strlen(parameters) > 0 ) + { + WriteLog("·SAPϢʧܣ\nϢstrResult%s\nĿattachments_num%d\n", strResult.c_str(), attachments_num); + WriteLog("ƴӲparameters%s\n", parameters); + strResult = strResult.substr(0, iSize - 1); + printf("·ʧ\n"); + printf("Ϣ%s\n",strResult.c_str()); + printf("Ŀ%d\n",attachments_num); + for (int i = 0; i < attachments_num; i++) + { + + //ȡobject_type + AOM_ask_value_string(attachments[i], "object_type", &object_type); + printf("object_type=%s \n", object_type); + WriteLog("ǰĿobject_type=%s \n", object_type); + if (strcmp("Gd6_PartsRevision", object_type) == 0 || strcmp("Gd6_VehicleRevision", object_type) == 0 + || strcmp("Gd6_XZMKCRevision", object_type) == 0 || strcmp("Gd6_BZJRevision", object_type) == 0 + || strcmp("Gd6_PTJRevision", object_type) == 0) { + //printf("111111111"); + WriteLog("object_type=%s in [Gd6_PartsRevision,Gd6_VehicleRevision,Gd6_XZMKCRevision,Gd6_BZJRevision,Gd6_PTJRevision]\n", object_type); + char * item_id_value = NULL; + //ȡPUID + AOM_ask_value_string(attachments[i], "item_id", &item_id_value); + WriteLog("ͨitem_idԻȡitem_id_value=%s\n", item_id_value); + //printf("222\n"); + + strcat(item_id_value, ""); + //printf("%s",item_id_value); + if(strstr(strResult.c_str(),item_id_value) == NULL) + { + WriteLog("strResultв=item_id_valueʱ\n"); + //printf("44"); + int item_mast_rev_count = 0; + tag_t *item_mast_rev = NULLTAG; + + //ȡ汾 + ITKCALL(AOM_ask_value_tags(attachments[i], "IMAN_master_form_rev", &item_mast_rev_count, &item_mast_rev )); + + WriteLog("ʼİ汾Ƿ·Ϊǡ\n"); + //İ汾Ƿ·Ϊǡ + POM_AM__set_application_bypass(true); + //lock + AOM_lock(item_mast_rev[0]); + //set + AOM_set_value_string(item_mast_rev[0],"gd6_sfyxf",""); + //save + AOM_save( item_mast_rev[0] ) ; + //unlock + AOM_unlock( item_mast_rev[0] ) ; + AOM_refresh( item_mast_rev[0],FALSE ); + + POM_AM__set_application_bypass(false); + + MEM_free(item_mast_rev); + item_mast_rev = NULL; + } + + //MEM_free(object_type); + //object_type = NULL; + + //MEM_free(item_id_value); + //item_id_value = NULL; + + } + } + + printf("ʼֵ\n"); + WriteLog("ʼֵ\n"); + POM_AM__set_application_bypass(true); + //ȡҵ + tag_t job = NULLTAG; + EPM_ask_job(rootTask,&job); + //ֵ + //lock + AOM_lock(job); + //set + ITKCALL(ifail = AOM_set_value_string(job,"object_desc","SAPϢʧܣʧԭ鿴־")); + //save + AOM_save( job ) ; + //unlock + AOM_unlock( job ) ; + AOM_refresh( job,FALSE ); + //AOM_refresh( rootTask,FALSE ); + POM_AM__set_application_bypass(false); + + //EMH_store_error_s1( EMH_severity_user_error, EMH_USER_error_base,strResult.c_str()); + //ifail = 1; + } + else + { + printf("ɹ·sap"); + WriteLog("·sapɹ\n"); + for (int i = 0; i < attachments_num; i++) + { + + //ȡobject_type + ITKCALL(ifail = AOM_ask_value_string(attachments[i], "object_type", &object_type)); + printf("object_type=%s \n", object_type); + WriteLog("ʾĿµǰ=object_type=%s \n", object_type); + + if (strcmp("Gd6_PartsRevision", object_type) == 0 || strcmp("Gd6_VehicleRevision", object_type) == 0 + || strcmp("Gd6_XZMKCRevision", object_type) == 0 || strcmp("Gd6_BZJRevision", object_type) == 0 + || strcmp("Gd6_PTJRevision", object_type) == 0) { + WriteLog("object_type=%s in [Gd6_PartsRevision,Gd6_VehicleRevision,Gd6_XZMKCRevision,Gd6_BZJRevision,Gd6_PTJRevision]\n", object_type); + int item_mast_rev_count = 0; + tag_t *item_mast_rev NULLTAG; + + //ȡ汾 + ITKCALL(AOM_ask_value_tags(attachments[i], "IMAN_master_form_rev", &item_mast_rev_count, &item_mast_rev )); + WriteLog("ʼİ汾Ƿ·Ϊǡ\n"); + //İ汾Ƿ·Ϊǡ + POM_AM__set_application_bypass(true); + //lock + AOM_lock(item_mast_rev[0]); + //set + AOM_set_value_string(item_mast_rev[0],"gd6_sfyxf",""); + //save + AOM_save( item_mast_rev[0] ) ; + //unlock + AOM_unlock( item_mast_rev[0] ) ; + AOM_refresh( item_mast_rev[0],FALSE ); + + POM_AM__set_application_bypass(false); + + MEM_free(item_mast_rev); + item_mast_rev = NULL; + + MEM_free(object_type); + object_type = NULL; + } + } + POM_AM__set_application_bypass(true); + //ȡҵ + tag_t job = NULLTAG; + EPM_ask_job(rootTask,&job); + WriteLog("ʼֵ\n"); + //ֵ + //lock + AOM_lock(job); + //set + AOM_set_value_string(job,"object_desc","ɹ·"); + //save + AOM_save( job ) ; + //unlock + AOM_unlock( job ) ; + AOM_refresh( job,FALSE ); + //AOM_refresh( rootTask,FALSE ); + POM_AM__set_application_bypass(false); + + } + //else + //{ + // //if (strcmp("", isSend) != 0) + // //{ + // //İ汾Ƿ·Ϊǡ + // POM_AM__set_application_bypass(true); + + // //ֵ + // //lock + // AOM_lock(item_mast_rev[0]); + // //set + // AOM_set_value_string(item_mast_rev[0],"gd6_sfyxf",""); + // //save + // AOM_save( item_mast_rev[0] ) ; + // //unlock + // AOM_unlock( item_mast_rev[0] ) ; + // AOM_refresh( item_mast_rev[0],FALSE ); + + // POM_AM__set_application_bypass(false); + // //} + //} + + //POM_AM__set_application_bypass(true); + //AOM_refresh( rootTask,FALSE ); + //POM_AM__set_application_bypass(false); + printf("ϴݵSAPִн1\n"); + WriteLog("ϴݵSAPִнʼͷŶ\n"); + MEM_free(attachments); + attachments = NULL; + tc_root_file = NULL; + MEM_free(item_rev_value); + item_rev_value = NULL; + server_address = NULL; + MEM_free(handler_name); + handler_name = NULL; + printf("ϴݵSAPִн2\n"); + WriteLog("ϴݵSAPͷſռhandlerִɣ\n"); + + CloseLog(); + return ifail; +} + +void getBomLineItemPropertys(tag_t top_line, int bl_item_id_num) { + //printf("ʼִgetBomLineItemPropertys\n"); + + int count; + tag_t *children_line; + char parameter[100000] = "getBomMasterDataPropertys,"; + + tag_t item_rev; + char *item_rev_value; + int valueNum; + char **server_address; + + char *tc_root_file = getenv("tc_root"); //C:\Siemens\Teamcenter11 + char jar_file[SS_MAXPATHLEN] = ""; + strcpy(jar_file, tc_root_file); + strcat(jar_file, "\\portal\\plugins\\"); + strcat(jar_file, "JLCS_05.jar"); + + PREF_ask_char_values("JL_BOMSendSapMasterData", &valueNum, &server_address);//ѡ + + + BOM_line_ask_all_child_lines(top_line, &count, &children_line); + //printf("=%d \n", count); + for (int ii = 0; ii < count; ii++) + { + BOM_line_look_up_attribute("bl_line_object", &bl_item_id_num); + BOM_line_ask_attribute_tag(children_line[ii], bl_item_id_num, &item_rev);//ð汾 + + //printf("ʼѡvalueNum=%d\n", valueNum); + char *revbuf[8] = { 0 }; //ŷַָ + int num = 0;//ַָĸ + for (int ij = 0; ij < valueNum; ij++) { + //revbuf[8] = { 0 }; + num = 0; + split(server_address[ij], "/", revbuf, &num); + strcat(parameter, revbuf[0] == NULL || strlen(revbuf[0]) == 0 ? "" : revbuf[0]); + strcat(parameter, "="); + + AOM_UIF_ask_value(item_rev, revbuf[1], &item_rev_value); + + strcat(parameter, item_rev_value); + strcat(parameter, ""); + } + //printf("parameter======:\n%s\n", parameter); + + //дļ + char data_file[SS_MAXPATHLEN] = ""; + strcat(data_file,tc_root_file); + strcat(data_file,"\\data.txt"); + FILE* fptr; + fptr = fopen(data_file, "w"); + fprintf(fptr, "%s", parameter); + fclose(fptr); + + //cmdָ + char cmd[256] = ""; + strcpy(cmd, "java -jar \""); + strcat(cmd,tc_root_file); + strcat(cmd,"\\portal\\plugins\\"); + strcat(cmd,"JLCS_05.jar"); + strcat(cmd, "\" "); + // + cout< 0 && strResult[iSize - 1] == '\n' && strlen(parameters) > 0) + { + strResult = strResult.substr(0, iSize - 1); + + //ȡҵ + tag_t job = NULLTAG; + + EPM_ask_job(rootTask,&job); + POM_AM__set_application_bypass(true); + //ֵ + //lock + AOM_lock(job); + //set + AOM_set_value_string(job,"object_desc",strResult.c_str()); + //save + AOM_save( job ) ; + //unlock + AOM_unlock( job ) ; + AOM_refresh( job,FALSE ); + POM_AM__set_application_bypass(false); + + //EMH_store_error_s1( EMH_severity_user_error, EMH_USER_error_base,strResult.c_str()); + //ifail = 1; + } + + MEM_free(attachments); + attachments = NULL; + tc_root_file = NULL; + MEM_free(handler_name); + handler_name = NULL; + printf("ִн\n"); + + return ifail; +} + +int JLCS_05_BOMUpdateSap_MasterData(EPM_action_message_t msg) +{ + printf("ʼִϴݵSAP\n"); + + int ifail = ITK_ok; + int valueNum; + char **server_address; + //printf("ʼȡѡ\n"); + + int attachments_num; + int bvr_count; + tag_t rootTask, *attachments, *bvr_list = NULLTAG; + tag_t bom_window_tag = NULLTAG; + char *object_type; + int count; + tag_t item_rev; + + + char *item_rev_value = NULL; + + char *tc_root_file = getenv("tc_root"); //C:\Siemens\Teamcenter11 + char jar_file[SS_MAXPATHLEN] = ""; + + + + + //ȡ + EPM_ask_root_task(msg.task, &rootTask); + //ȡĿ + EPM_ask_attachments(rootTask, EPM_target_attachment, &attachments_num, &attachments); + //char *temp_dir = getenv("temp"); //C:\Windows\temp + + char *handler_name; + AOM_ask_value_string(rootTask,"job_name",&handler_name); + + char parameters[100000] = ""; + + for (int i = 0; i < attachments_num; i++) + { + + //ȡtopline + AOM_ask_value_string(attachments[i], "object_type", &object_type); + printf("object_type=%s \n", object_type); + + if (strcmp("Gd6_PartsRevision", object_type) == 0 || strcmp("Gd6_VehicleRevision", object_type) == 0 + || strcmp("Gd6_XZMKCRevision", object_type) == 0 || strcmp("Gd6_BZJRevision", object_type) == 0 + || strcmp("Gd6_PTJRevision", object_type) == 0) { + + + //ITEM_rev_list_bom_view_revs(attachments[i], &bvr_count, &bvr_list); + //printf("ͼ=%d \n", bvr_count); + + //if (bvr_count == 0) { + // continue; + //} + //ȡBOM topline + //BOM_create_window(&bom_window_tag); + //BOM_set_window_top_line_bvr(bom_window_tag, bvr_list[bvr_count - 1], &top_line); + //BOM_ask_window_top_line(bom_window_tag, &top_line); + //printf("ʼȡ汾\n"); + char * puid = NULL; + //ȡPUID + ITK__convert_tag_to_uid(attachments[i], &puid); + + int item_mast_rev_count = 0; + tag_t *item_mast_rev NULLTAG; + + //ȡ汾 + ITKCALL(AOM_ask_value_tags(attachments[i], "IMAN_master_form_rev", &item_mast_rev_count, &item_mast_rev )); + + //жǷѵ + //char * isSend = NULL; + //AOM_ask_value_string(item_mast_rev[0],"gd6_sfyxf", &isSend); + + //printf("Ƿѵ:%s\n", isSend); + + + + + //strcat(parameters, puid); + //strcat(parameters, "}}"); + + //if (strcmp("", isSend) == 0) + //{ + PREF_ask_char_values("JL_BOMUpdateMasterData", &valueNum, &server_address);//ѡ + strcpy(parameters,"updateBomMasterDataPropertys}}"); + + strcat(parameters, puid); + strcat(parameters, "}}"); + //} + //else + //{ + // PREF_ask_char_values("JL_BOMSendSapMasterData", &valueNum, &server_address);//ѡ + //} + + + + + //BOM_line_ask_attribute_tag(top_line, bl_item_id_num, &item_rev);//ð汾 + + //printf("ʼѡ\n"); + char *revbuf[8] = { 0 }; //ŷַָ + int num = 0;//ַָĸ + for (int ii = 0; ii < valueNum; ii++) { + //revbuf[8] = { 0 }; //ŷַָ + num = 0;//ַָĸ + split(server_address[ii], "/", revbuf, &num); + strcat(parameters, revbuf[0] == NULL || strlen(revbuf[0]) == 0 ? "": revbuf[0]); + strcat(parameters, "="); + + if(strstr(revbuf[1],"item_id") != NULL || strstr(revbuf[1],"object_name") != NULL) + { + AOM_ask_value_string(attachments[i], revbuf[1], &item_rev_value); + } + else + { + AOM_ask_value_string(item_mast_rev[0], revbuf[1], &item_rev_value); + } + + strcat(parameters, item_rev_value); + strcat(parameters, ""); + } + //printf("parameters=====%s\n", parameters); + + + strcat(parameters, "@@"); + + //printf("ӿڷֵ:%s\n", strResult.c_str()); + //system(cmd); + //getBomLineItemPropertys(top_line, bl_item_id_num); + MEM_free(bvr_list); + bvr_list = NULL; + MEM_free(object_type); + object_type = NULL; + //MEM_free(isSend); + //isSend = NULL; + MEM_free(puid); + puid = NULL; + } + } + + strcpy(jar_file, tc_root_file); + strcat(jar_file, "\\portal\\plugins\\"); + strcat(jar_file, "JLCS_05.jar"); + + //дļ + char data_file[SS_MAXPATHLEN] = ""; + strcat(data_file,tc_root_file); + strcat(data_file,"\\data.txt"); + FILE* fptr; + fptr = fopen(data_file, "w"); + fprintf(fptr, "%s", parameters); + fclose(fptr); + + string strResult; + + //cmdָ + char cmd[256] = ""; + strcpy(cmd, "java -jar \""); + //strcat(cmd, jar_file); + strcat(cmd,tc_root_file); + strcat(cmd,"\\portal\\plugins\\"); + strcat(cmd,"JLCS_05.jar"); + strcat(cmd, "\" "); + // + cout< 0 && strResult[iSize - 1] == '\n' && strlen(parameters) > 0) + { + strResult = strResult.substr(0, iSize - 1); + + //ȡҵ + tag_t job = NULLTAG; + + EPM_ask_job(rootTask,&job); + POM_AM__set_application_bypass(true); + //ֵ + //lock + AOM_lock(job); + //set + AOM_set_value_string(job,"object_desc",strResult.c_str()); + //save + AOM_save( job ) ; + //unlock + AOM_unlock( job ) ; + AOM_refresh( job,FALSE ); + POM_AM__set_application_bypass(false); + //EMH_store_error_s1( EMH_severity_user_error, EMH_USER_error_base,strResult.c_str()); + //ifail = 1; + } + + + MEM_free(attachments); + attachments = NULL; + tc_root_file = NULL; + MEM_free(item_rev_value); + item_rev_value = NULL; + server_address = NULL; + MEM_free(handler_name); + handler_name = NULL; + printf("ϴݵSAPִн\n"); + + return ifail; +} + +//void getBomLineItemPropertys(tag_t top_line, int bl_item_id_num) { +// //printf("ʼִgetBomLineItemPropertys\n"); +// +// int count; +// tag_t *children_line; +// char parameter[5120] = "getBomMasterDataPropertys,"; +// +// tag_t item_rev; +// char *item_rev_value; +// int valueNum; +// char **server_address; +// +// char *tc_root_file = getenv("tc_root"); //C:\Siemens\Teamcenter11 +// char jar_file[SS_MAXPATHLEN] = ""; +// strcpy(jar_file, tc_root_file); +// strcat(jar_file, "\\portal\\plugins\\"); +// strcat(jar_file, "JLCS_05.jar"); +// +// PREF_ask_char_values("JL_BOMSendSapMasterData", &valueNum, &server_address);//ѡ +// +// +// BOM_line_ask_all_child_lines(top_line, &count, &children_line); +// //printf("=%d \n", count); +// for (int ii = 0; ii < count; ii++) +// { +// BOM_line_look_up_attribute("bl_line_object", &bl_item_id_num); +// BOM_line_ask_attribute_tag(children_line[ii], bl_item_id_num, &item_rev);//ð汾 +// +// //printf("ʼѡvalueNum=%d\n", valueNum); +// char *revbuf[8] = { 0 }; //ŷַָ +// int num = 0;//ַָĸ +// for (int ij = 0; ij < valueNum; ij++) { +// //revbuf[8] = { 0 }; +// num = 0; +// split(server_address[ij], "/", revbuf, &num); +// strcat(parameter, revbuf[0] == NULL || strlen(revbuf[0]) == 0 ? "" : revbuf[0]); +// strcat(parameter, "="); +// +// AOM_UIF_ask_value(item_rev, revbuf[1], &item_rev_value); +// +// strcat(parameter, item_rev_value); +// strcat(parameter, ","); +// } +// //printf("parameter======:\n%s\n", parameter); +// +// char cmd[256] = ""; +// strcpy(cmd, "java -jar \""); +// strcat(cmd, jar_file); +// strcat(cmd, "\" "); +// // +// strcat(cmd, parameter); +// //printf("·:\n%s\n", cmd); +// system(cmd); +// +// getBomLineItemPropertys(children_line[ii], bl_item_id_num); +// } +// printf("ִн \n"); +// +//} + + +//int JLCS_05_BOMDeleteSap_MasterData(EPM_action_message_t msg) +//{ +// printf("ʼִ\n"); +// +// int ifail = ITK_ok; +// //printf("ʼȡѡ\n"); +// +// int attachments_num; +// tag_t rootTask, *attachments; +// char *object_type; +// +// char *tc_root_file = getenv("tc_root"); //C:\Siemens\Teamcenter11 +// char jar_file[SS_MAXPATHLEN] = ""; +// strcpy(jar_file, tc_root_file); +// strcat(jar_file, "\\portal\\plugins\\"); +// strcat(jar_file, "JLCS_05.jar"); +// +// +// +// //ȡ +// EPM_ask_root_task(msg.task, &rootTask); +// //ȡĿ +// EPM_ask_attachments(rootTask, EPM_target_attachment, &attachments_num, &attachments); +// //char *temp_dir = getenv("temp"); //C:\Windows\temp +// +// +// for (int i = 0; i < attachments_num; i++) +// { +// +// //ȡtopline +// AOM_ask_value_string(attachments[i], "object_type", &object_type); +// //printf("object_type=%s \n", object_type); +// +// if (strcmp("Gd6_PartsRevision", object_type) == 0) { +// +// //printf("ʼȡ汾\n"); +// char * puid = NULL; +// char * itemId = NULL; +// //ȡPUID +// ITK__convert_tag_to_uid(attachments[i], &puid); +// //ȡITEM_ID +// AOM_ask_value_string(attachments[i], "item_id", &itemId); +// +// char parameters[5120] = "deleteBomMasterDataPropertys}}"; +// +// strcat(parameters, puid); +// strcat(parameters, "}}"); +// strcat(parameters, itemId); +// +// //cmdָ +// char cmd[256] = ""; +// strcpy(cmd, "java -jar \""); +// strcat(cmd, jar_file); +// strcat(cmd, "\" "); +// // +// strcat(cmd, parameters); +// printf("·:\n%s\n", cmd); +// char buf[10240] = { 0 }; +// FILE *pf = NULL; +// if ((pf = _popen(cmd, "r")) == NULL) { +// printf("ӿڷ:\n%s", "1"); +// } +// string strResult; +// while (fgets(buf, sizeof buf, pf)) { +// strResult += buf; +// } +// _pclose(pf); +// unsigned int iSize = strResult.size(); +// if (iSize > 0 && strResult[iSize - 1] == '\n') +// { +// strResult = strResult.substr(0, iSize - 1); +// +// //ȡҵ +// tag_t job = NULLTAG; +// +// EPM_ask_job(rootTask,&job); +// +// //ֵ +// //lock +// AOM_lock(job); +// //set +// AOM_set_value_string(job,"object_desc",strResult.c_str()); +// //save +// AOM_save( job ) ; +// //unlock +// AOM_unlock( job ) ; +// AOM_refresh( job,FALSE ); +// +// //EMH_store_error_s1( EMH_severity_user_error, EMH_USER_error_base,strResult.c_str()); +// //ifail = 1; +// } +// //printf("ӿڷֵ:%s\n", strResult.c_str()); +// //system(cmd); +// //getBomLineItemPropertys(top_line, bl_item_id_num); +// MEM_free(object_type); +// object_type = NULL; +// MEM_free(puid); +// puid = NULL; +// } +// } +// +// MEM_free(attachments); +// attachments = NULL; +// tc_root_file = NULL; +// printf("ִн\n"); +// +// return ifail; +//} + + + diff --git a/CONNOR_ITK/JL_Add_FinishTime.cpp b/CONNOR_ITK/JL_Add_FinishTime.cpp new file mode 100644 index 0000000..b776f3d --- /dev/null +++ b/CONNOR_ITK/JL_Add_FinishTime.cpp @@ -0,0 +1,336 @@ +#include "epm_handler_common.h" +#include +#include +#include "dos.h" +#include "sstream" +#include +#include +#include "time.h" +#include "stdio.h" +#include +extern "C" int POM_AM__set_application_bypass(logical bypass); +using namespace std; + +#define DOFREE(obj) \ +{ \ + if(obj) \ + { \ + MEM_free(obj); \ + obj = NULL; \ + } \ +} + +string intToString(int a){ + stringstream ss; + ss << a; + string str = ss.str(); + return str; +} + +int JL_Add_FinishTime(EPM_action_message_t msg){ + int ifail = ITK_ok,count = 0; + tag_t *sub = NULLTAG,rootTask = NULLTAG; + char *name = NULL; + cout << "ʼִ" << endl; + //ȡ + EPM_ask_root_task(msg.task, &rootTask); + //õǰʱ + + struct tm *local; + time_t t; + t=time(NULL); + local=localtime(&t); + cout << local <tm_year <tm_mon <tm_mday <tm_hour <tm_min<tm_sec<tm_wday<tm_hour > 12 && local->tm_hour <=23){ + if(local->tm_mon == 0 || local->tm_mon == 2 || local->tm_mon == 4 || + local->tm_mon == 6 || local->tm_mon == 7 || local->tm_mon == 9 || + local->tm_mon == 11 ){ + if(local->tm_wday == 5){ + //壨+3죩 + if(local->tm_mday < 29){ + sprintf(year, "%d", local->tm_year+1900); + sprintf(month, "%d", local->tm_mon+1); + sprintf(day, "%d", local->tm_mday+3); + } + //29 + else if(local->tm_mday == 29){ + //12 + if(local->tm_mon == 11){ + sprintf(year, "%d", local->tm_year+1901); + sprintf(month, "%d", 1); + sprintf(day, "%d", 1); + } + else{ + sprintf(year, "%d", local->tm_year+1900); + sprintf(month, "%d", local->tm_mon+2); + sprintf(day, "%d", 1); + } + } + //30 + else if(local->tm_mday == 30){ + //12 + if(local->tm_mon == 11){ + sprintf(year, "%d", local->tm_year+1901); + sprintf(month, "%d", 1); + sprintf(day, "%d", 2); + } + else{ + sprintf(year, "%d", local->tm_year+1900); + sprintf(month, "%d", local->tm_mon+2); + sprintf(day, "%d", 2); + } + } + //31 + else{ + //12 + if(local->tm_mon == 11){ + sprintf(year, "%d", local->tm_year+1901); + sprintf(month, "%d", 1); + sprintf(day, "%d", 3); + } + else{ + sprintf(year, "%d", local->tm_year+1900); + sprintf(month, "%d", local->tm_mon+2); + sprintf(day, "%d", 3); + } + } + } + else{ + //壨+1죩 + if(local->tm_mday < 31){ + sprintf(year, "%d", local->tm_year+1900); + sprintf(month, "%d", local->tm_mon+1); + sprintf(day, "%d", local->tm_mday+1); + } + else{ + //1231 + if(local->tm_mon == 11){ + sprintf(year, "%d", local->tm_year+1901); + sprintf(month, "%d", 1); + sprintf(day, "%d", 1); + } + else{ + sprintf(year, "%d", local->tm_year+1900); + sprintf(month, "%d", local->tm_mon+2); + sprintf(day, "%d", 1); + } + + } + } + } + else if(local->tm_mon == 3 || local->tm_mon == 5 || local->tm_mon == 8 || local->tm_mon == 10){ + if(local->tm_wday == 5){ + if(local->tm_mday < 28){ + sprintf(year, "%d", local->tm_year+1900); + sprintf(month, "%d", local->tm_mon+1); + sprintf(day, "%d", local->tm_mday+3); + } + //28 + else if(local->tm_mday == 28){ + sprintf(year, "%d", local->tm_year+1900); + sprintf(month, "%d", local->tm_mon+2); + sprintf(day, "%d", 1); + } + //29 + else if(local->tm_mday == 29){ + sprintf(year, "%d", local->tm_year+1900); + sprintf(month, "%d", local->tm_mon+2); + sprintf(day, "%d", 2); + } + //30 + else{ + sprintf(year, "%d", local->tm_year+1900); + sprintf(month, "%d", local->tm_mon+2); + sprintf(day, "%d", 3); + } + } + else{ + if(local->tm_mday < 30){ + sprintf(year, "%d", local->tm_year+1900); + sprintf(month, "%d", local->tm_mon+1); + sprintf(day, "%d", local->tm_mday+1); + } + else{ + sprintf(year, "%d", local->tm_year+1900); + sprintf(month, "%d", local->tm_mon+2); + sprintf(day, "%d", 1); + } + } + } + //2 + else{ + //жǷ꣨29죩 + int leap_year = local->tm_year+1900; + //꣨29죩 + if((leap_year % 4 == 0 && leap_year % 100 != 0) || (leap_year % 400 == 0)){ + if(local->tm_wday == 5){ + if(local->tm_mday < 27){ + sprintf(year, "%d", local->tm_year+1900); + sprintf(month, "%d", local->tm_mon+1); + sprintf(day, "%d", local->tm_mday+3); + } + //27 + else if(local->tm_mday == 27){ + sprintf(year, "%d", local->tm_year+1900); + sprintf(month, "%d", local->tm_mon+2); + sprintf(day, "%d", 1); + } + //28 + else if(local->tm_mday == 28){ + sprintf(year, "%d", local->tm_year+1900); + sprintf(month, "%d", local->tm_mon+2); + sprintf(day, "%d", 2); + } + //29 + else{ + sprintf(year, "%d", local->tm_year+1900); + sprintf(month, "%d", local->tm_mon+2); + sprintf(day, "%d", 3); + } + } + else{ + if(local->tm_mday < 29){ + sprintf(year, "%d", local->tm_year+1900); + sprintf(month, "%d", local->tm_mon+1); + sprintf(day, "%d", local->tm_mday+1); + } + else{ + sprintf(year, "%d", local->tm_year+1900); + sprintf(month, "%d", local->tm_mon+2); + sprintf(day, "%d", 1); + } + } + } + //꣨28죩 + else{ + if(local->tm_wday == 5){ + if(local->tm_mday < 26){ + sprintf(year, "%d", local->tm_year+1900); + sprintf(month, "%d", local->tm_mon+1); + sprintf(day, "%d", local->tm_mday+3); + } + //26 + else if(local->tm_mday == 26){ + sprintf(year, "%d", local->tm_year+1900); + sprintf(month, "%d", local->tm_mon+2); + sprintf(day, "%d", 1); + } + //27 + else if(local->tm_mday == 27){ + sprintf(year, "%d", local->tm_year+1900); + sprintf(month, "%d", local->tm_mon+2); + sprintf(day, "%d", 2); + } + //28 + else{ + sprintf(year, "%d", local->tm_year+1900); + sprintf(month, "%d", local->tm_mon+2); + sprintf(day, "%d", 3); + } + } + else{ + if(local->tm_mday < 28){ + sprintf(year, "%d", local->tm_year+1900); + sprintf(month, "%d", local->tm_mon+1); + sprintf(day, "%d", local->tm_mday+1); + } + else{ + sprintf(year, "%d", local->tm_year+1900); + sprintf(month, "%d", local->tm_mon+2); + sprintf(day, "%d", 1); + } + } + } + + } + sprintf(hour, "%d", 12); + } + //ܣ + else{ + sprintf(year, "%d", local->tm_year+1900); + sprintf(month, "%d", local->tm_mon+1); + sprintf(day, "%d", local->tm_mday); + sprintf(hour, "%d", 17); + //sprintf(min, "%d", local->tm_min); + } + + + //string year = intToString(local->tm_year+1900); + //string month = intToString(local->tm_mon+1); + //string day = intToString(local->tm_mday); + //string hour = intToString(local->tm_hour); + //string min = intToString(local->tm_min); + //string nowTime = year + ""+month+""+day+"" + hour+":"+min; + cout << nowTime < +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +extern "C" int POM_AM__set_application_bypass(logical bypass); + +using namespace std; + +#define DOFREE(obj) \ +{ \ + if(obj) \ + { \ + MEM_free(obj); \ + obj = NULL; \ + } \ +} + +int JL_Change_Inspection_Of_Basic_Part(EPM_rule_message_t msg) +{ + printf("ʼִ\n"); + + + int ifail, attachments_num, relation_num ; + tag_t rootTask, *attachments, *C8RelationModification; + char *item_id, *c8BasicPartMaterialNum, *C8RelationModification_object_string = NULL; + char * IsBasicParts; + + int EPM_decision = ITK_ok; + //ѯ + int status; + int num_found = 0; + int entry_count = 0; + int item_mast_rev_count = 0; + tag_t * item_mast_rev = NULLTAG; + //tag_t query_tag = NULLTAG; + /*char** entries; + char** values; + char *other_values[1]; + char *other_entrys[1]; + tag_t* results; + other_values[0] = (char*)calloc(48, sizeof(char)); + other_entrys[0] = (char*)calloc(48, sizeof(char)); + const char query_name_ggtz[QRY_name_size_c + 1] = { "ݻϺŲѯ㲿" };*/ + + //ȡ + EPM_ask_root_task(msg.task, &rootTask); + //ȡĿ + EPM_ask_attachments(rootTask, EPM_target_attachment, &attachments_num, &attachments); + + for (int i = 0; i < attachments_num; i++) + { + char * type_class = NULL; + ITKCALL(AOM_ask_value_string(attachments[i], "object_type", &type_class)); + //˵Ǹĵ汾Ķ + if(stricmp(type_class,"Gd6_ChangeRevision") != NULL) + { + DOFREE(type_class); + continue; + } + + + char * message = (char*) calloc (512, sizeof(char)); + char * errorValue = (char*) calloc (64, sizeof(char)); + + AOM_ask_value_string(attachments[i], "item_id", &item_id); + + //ȡĿ󡰱㲿µж + AOM_ask_value_tags(attachments[i], "Gd6_BGLBJ", &relation_num, &C8RelationModification); + + for (int j = 0; j < relation_num; j++) { + //ȡ汾 + /*ITKCALL(AOM_ask_value_tags(C8RelationModification[j], "IMAN_master_form_rev", &item_mast_rev_count, &item_mast_rev ) ) + AOM_ask_value_string(C8RelationModification[j], "object_string", &C8RelationModification_object_string); + AOM_ask_value_string(item_mast_rev[0], "gd6_sfjcj", &IsBasicParts); + printf("IsBasicParts---------------- %s", IsBasicParts); + if (stricmp(IsBasicParts,"N") == 0) + { + printf("㲿µ[%d][%s]ǻ\n", j+1,C8RelationModification_object_string); + sprintf(errorValue, "㲿µ[%d][%s]ǻ\n", j+1,C8RelationModification_object_string); + strcat(message,errorValue); + + }*/ + //else + //{ + int rev_status_count = 0; + tag_t * rev_status = NULLTAG; + //жǷ񷢲 + ITKCALL(AOM_ask_value_tags(C8RelationModification[j],"release_status_list",&rev_status_count, &rev_status)); + if(rev_status_count > 0) + { + printf("㲿µ[%d][%s]ѷ\n", j+1,C8RelationModification_object_string); + sprintf(errorValue, "㲿µ[%d][%s]ѷ\n", j+1,C8RelationModification_object_string); + strcat(message,errorValue); + } + DOFREE(rev_status); + //} + + + + // + } + + //ȡĿ㲿µж + AOM_ask_value_tags(attachments[i], "Gd6_XGFJ", &relation_num, &C8RelationModification); + + for (int j = 0; j < relation_num; j++) { + //ȡ汾 + ITKCALL(AOM_ask_value_tags(C8RelationModification[j], "IMAN_master_form_rev", &item_mast_rev_count, &item_mast_rev ) ) + AOM_ask_value_string(C8RelationModification[j], "object_string", &C8RelationModification_object_string); + AOM_ask_value_string(item_mast_rev[0], "gd6_sfjcj", &IsBasicParts); + printf("IsBasicParts---------------- %s", IsBasicParts); + if (stricmp(IsBasicParts,"Y") == 0) + { + printf("㲿µ[%d]ǻ\n", j+1); + + sprintf(errorValue, "㲿µ[%d][%s]ǻ\n", j+1,C8RelationModification_object_string); + strcat(message,errorValue); + + } + + int rev_status_count = 0; + tag_t * rev_status = NULLTAG; + //жǷ񷢲 + ITKCALL(AOM_ask_value_tags(C8RelationModification[j],"release_status_list",&rev_status_count, &rev_status)); + if(rev_status_count > 0) + { + printf("㲿µ[%d][%s]ѷ\n", j+1,C8RelationModification_object_string); + sprintf(errorValue, "㲿µ[%d][%s]ѷ\n", j+1,C8RelationModification_object_string); + strcat(message,errorValue); + } + DOFREE(rev_status); + + /*else + {*/ + + ////жϸĺǷΪδİ汾 + + ////ȡ汾 + //int item_mast_rev_count = 0; + //tag_t * item_mast_revl = NULLTAG; + ////ȡ汾 + //AOM_ask_value_string(item_mast_rev[0], "gd6_jcjwlh", &c8BasicPartMaterialNum); + //AOM_ask_value_string(attachments[i], "item_id", &item_id); + //if (strcmp(item_id, c8BasicPartMaterialNum) != 0) + //{ + // printf("[%s]Ļ[%s][%s]\n", C8RelationModification_object_string, c8BasicPartMaterialNum, item_id); + // char * message = (char*) calloc (64, sizeof(char)); + // sprintf(message,"[%s]Ļ[%s][%s]\n", C8RelationModification_object_string,c8BasicPartMaterialNum , item_id); + // EMH_store_error_s1( EMH_severity_user_error, EMH_USER_error_base,message); + // message = NULL; + // item_mast_revl = NULL; + // DOFREE(type_class); + // DOFREE(item_id); + // DOFREE(attachments); + // DOFREE(item_mast_rev); + // DOFREE(C8RelationModification_object_string); + // DOFREE(C8RelationModification); + // EPM_decision = 1; + // return EPM_decision; + //} + //} + } + + if(strlen(message) > 1) + { + EMH_store_error_s1( EMH_severity_user_error, EMH_USER_error_base,message); + message = NULL; + /*DOFREE(type_class); + DOFREE(item_id); + DOFREE(attachments); + DOFREE(item_mast_rev); + DOFREE(C8RelationModification_object_string); + DOFREE(C8RelationModification);*/ + EPM_decision = 1; + //return EPM_decision; + } + + + //ѯԱ + //ITKCALL( QRY_find(query_name_ggtz, &query_tag) ); + //QRY_find(query_name_ggtz, &query_tag); + //if (query_tag == NULLTAG) + //{ + // printf("query_tag=NULLTAG,ûҵ [%s]ѯ\n", query_name_ggtz); + // char * message = (char*) calloc (64, sizeof(char)); + // sprintf(message,"query_tag=NULLTAG,ûҵ [%s]ѯ\n", query_name_ggtz); + // EMH_store_error_s1( EMH_severity_user_error, EMH_USER_error_base,message); + // message = NULL; + // DOFREE(type_class); + // DOFREE(item_id); + // DOFREE(attachments); + // DOFREE(item_mast_rev); + // DOFREE(C8RelationModification_object_string); + // DOFREE(C8RelationModification); + // EPM_decision = 1; + // return EPM_decision; + // + //} + //else + //{ + // printf("ҵѯ\n"); + //} + ////ITKCALL(QRY_find_user_entries(query_tag, &entry_count, &entries, &values));//entriesѯʽvaluesѯֵMEM_freeͷţ + //QRY_find_user_entries(query_tag, &entry_count, &entries, &values); + //if (entry_count == 0) + //{ + // printf("entry_count=0,ѯûòѯ\n"); + // char * message = (char*) calloc (64, sizeof(char)); + // sprintf(message,"entry_count=0,ѯûòѯ\n"); + // EMH_store_error_s1( EMH_severity_user_error, EMH_USER_error_base,message); + // message = NULL; + // //ITK_exit_module(1); + // if (entries != NULL) { + // MEM_free(entries); + // entries = NULL; + // } + // if (values != NULL) { + // MEM_free(values); + // values = NULL; + // } + // + // DOFREE(type_class); + // DOFREE(item_id); + // DOFREE(attachments); + // DOFREE(item_mast_rev); + // DOFREE(C8RelationModification_object_string); + // DOFREE(C8RelationModification); + // EPM_decision = 1; + // return EPM_decision; + //} + + //for (int n = 0; n relation_num) { + // printf("[%s]µ\n", item_id); + // char * message = (char*) calloc (64, sizeof(char)); + // sprintf(message,"[%s]µ\n", item_id); + // EMH_store_error_s1( EMH_severity_user_error, EMH_USER_error_base,message); + // message = NULL; + // DOFREE(type_class); + // DOFREE(item_id); + // DOFREE(attachments); + // DOFREE(results); + // DOFREE(item_mast_rev); + // DOFREE(C8RelationModification_object_string); + // DOFREE(C8RelationModification); + + // EPM_decision = 1; + + // return EPM_decision; + //} + + DOFREE(type_class); + DOFREE(item_id); + DOFREE(C8RelationModification); + DOFREE(item_mast_rev); + DOFREE(C8RelationModification_object_string); + } + + DOFREE(attachments); + + printf("ִн\n"); + return EPM_decision; +} + + + +int Connor_set_bypass(void *returnValue) +{ + + POM_AM__set_application_bypass(true); + return 0; +} + +int ORIGIN_close_bypass(void *returnValue) +{ + POM_AM__set_application_bypass(false); + return 0; +} + +int Create_Remodel_Process(void *returnValue) +{ + printf("==================ӦԸ START =======================\n"); + + //ȡݹIJ + tag_t process = NULLTAG, tmp_select_signoff_task = NULLTAG, template_tag = NULLTAG; + int cnt_task = 0, signoff_cnt = 0; + tag_t * tasks = NULLTAG, * signoffs = NULLTAG; + char * processUser = NULL, * arctic = NULL; + char tmp_sub_task_name[WSO_name_size_c+1] = {'\0'}; + + ITKCALL(USERARG_get_tag_argument(&process)); + //ITKCALL(USERARG_get_tag_argument(&itemRevision)); + //ITKCALL(USERARG_get_string_argument(&processTemplate)); + ITKCALL(USERARG_get_string_argument(&processUser)); + // + ITKCALL(USERARG_get_string_argument(&arctic)); + + //// + ////ģEPM_find_templateģƣģͣģ + //ITKCALL( EPM_find_template( processTemplate, PROCESS_TEMPLATE, &template_tag) ); + + //printf("ȡģɹ!================\n"); + + + + + //int valueNum = 0; + //char ** values = NULL; + + //ȡѡֵ + + //printf("==================ȡѡֵ =======================\n"); + //PREF_ask_char_values(processUser, &valueNum, &values);//ѡ + + //for (int i = 0; i < valueNum; i++) + //{ + + //ֳ + //int arcticNum = 0; + //char ** arctics = new char *[64]; + + //ַָ + //split(values[i], "/", arctics, &arcticNum); + + //if(strstr(arctics[0],arctic) == NULL) + //{ + // continue; + //} + + //int num = 0; + //char ** nodeUsers = new char *[64]; + + //printf("ַ%s\n", arctics[1]); + //ַָ + //split(arctics[1], "-", nodeUsers, &num); + + //printf("ַ0%s\n", nodeUsers[0]); + //printf("ַ1%s\n", nodeUsers[1]); + + + + //EPM_ask_taskṣ״̬أ,ѿʼ + ITKCALL( EPM_ask_tasks(process,EPM_started, &cnt_task, &tasks )); + //EPM_assign_responsible_partyηηûҲԴ, + printf("%d+++++++++++++++++++++++++++\n",cnt_task); + for( int k = 0; k < cnt_task; k++ ) + { + //̽ڵ + ITKCALL( EPM_ask_name( tasks[k] , tmp_sub_task_name )); + + printf("̽ڵƣ%s+++++++++++++++++++++++++++\n",tmp_sub_task_name); + + ////̽ڵ + /*ITKCALL( AOM_ask_value_string( tasks[k] , "object_type" , &sub_task_object_type )); + printf("̽ڵ%s=====================\n",sub_task_object_type);*/ + + //if(strcmp(tmp_sub_task_name,nodeUsers[0]) == 0) + //{ + //ƻȡ + ITKCALL( EPM_ask_sub_task( tasks[k] , EPM_select_signoff_team_task , &tmp_select_signoff_task )); + + /*if(strstr(nodeUsers[1],",") != NULL) + { + char ** userIds = new char *[64]; + int userIdNum = 0; + + split(nodeUsers[1], ",", userIds, &userIdNum); + + for (int l = 0; l < userIdNum; l++) + { + tag_t user = NULLTAG; + ITKCALL( SA_find_user(userIds[l],&user)); + + ITKCALL( EPM_create_adhoc_signoff( tmp_select_signoff_task , user , &signoff_cnt , &signoffs ) ); + } + userIds = NULL; + + } + else + { + tag_t user = NULLTAG; + ITKCALL( SA_find_user(nodeUsers[1],&user)); + + ITKCALL( EPM_create_adhoc_signoff( tmp_select_signoff_task , user , &signoff_cnt , &signoffs ) ); + }*/ + + tag_t user = NULLTAG; + ITKCALL( SA_find_user(processUser,&user)); + + ITKCALL( EPM_create_adhoc_signoff( tmp_select_signoff_task , user , &signoff_cnt , &signoffs ) ); + + ITKCALL( EPM_set_adhoc_signoff_selection_done( tmp_select_signoff_task , true ) ); + ITKCALL(EPM_trigger_action(tmp_select_signoff_task,EPM_complete_action, "")); + DOFREE( signoffs ); + //} + } + + + //EPM_ask_taskṣ״̬أȴе + ITKCALL( EPM_ask_tasks(process,EPM_pending, &cnt_task, &tasks )); + //EPM_assign_responsible_partyηηûҲԴ, + printf("%d+++++++++++++++++++++++++++\n",cnt_task); + for( int k = 0; k < cnt_task; k++ ) + { + //̽ڵ + ITKCALL( EPM_ask_name( tasks[k] , tmp_sub_task_name )); + + printf("̽ڵƣ%s+++++++++++++++++++++++++++\n",tmp_sub_task_name); + + ////̽ڵ + /*ITKCALL( AOM_ask_value_string( tasks[k] , "object_type" , &sub_task_object_type )); + printf("̽ڵ%s=====================\n",sub_task_object_type);*/ + + //if(strcmp(tmp_sub_task_name,nodeUsers[0]) == 0) + //{ + //ƻȡ + ITKCALL( EPM_ask_sub_task( tasks[k] , EPM_select_signoff_team_task , &tmp_select_signoff_task )); + + /*if(strstr(nodeUsers[1],",") != NULL) + { + char ** userIds = new char *[64]; + int userIdNum = 0; + + split(nodeUsers[1], ",", userIds, &userIdNum); + + for (int l = 0; l < userIdNum; l++) + { + tag_t user = NULLTAG; + ITKCALL( SA_find_user(userIds[l],&user)); + + ITKCALL( EPM_create_adhoc_signoff( tmp_select_signoff_task , user , &signoff_cnt , &signoffs ) ); + } + userIds = NULL; + + } + else + { + tag_t user = NULLTAG; + ITKCALL( SA_find_user(nodeUsers[1],&user)); + + ITKCALL( EPM_create_adhoc_signoff( tmp_select_signoff_task , user , &signoff_cnt , &signoffs ) ); + }*/ + tag_t user = NULLTAG; + ITKCALL( SA_find_user(processUser,&user)); + ITKCALL( EPM_create_adhoc_signoff( tmp_select_signoff_task , user , &signoff_cnt , &signoffs ) ); + + ITKCALL( EPM_set_adhoc_signoff_selection_done( tmp_select_signoff_task , true ) ); + + + //ITKCALL(EPM_trigger_action(tmp_select_signoff_task,EPM_complete_action, "")); + DOFREE( signoffs ); + //} + } + //nodeUsers = NULL; + //arctics = NULL; + //} + + //DOFREE( values ); + DOFREE( processUser ); + DOFREE( arctic ); + DOFREE( tasks ); + printf("==================ӦԸ END =======================\n"); + + return ITK_ok; +} + +int DMU_Review_Process(void *returnValue) +{ + printf("==================ָԱ START =======================\n"); + + //ȡݹIJ + tag_t process = NULLTAG, tmp_select_signoff_task = NULLTAG, template_tag = NULLTAG; + int cnt_task = 0, signoff_cnt = 0; + tag_t * tasks = NULLTAG, * signoffs = NULLTAG; + char * processUser = NULL, * arctic = NULL; + char tmp_sub_task_name[WSO_name_size_c+1] = {'\0'}; + + ITKCALL(USERARG_get_tag_argument(&process)); + //ITKCALL(USERARG_get_tag_argument(&itemRevision)); + //ITKCALL(USERARG_get_string_argument(&processTemplate)); + ITKCALL(USERARG_get_string_argument(&processUser)); + // + ITKCALL(USERARG_get_string_argument(&arctic)); + + //// + ////ģEPM_find_templateģƣģͣģ + //ITKCALL( EPM_find_template( processTemplate, PROCESS_TEMPLATE, &template_tag) ); + + //printf("ȡģɹ!================\n"); + + + + + int valueNum = 0; + char ** values = NULL; + + //ȡѡֵ + + printf("==================ȡѡֵ =======================\n"); + PREF_ask_char_values(processUser, &valueNum, &values);//ѡ + + for (int i = 0; i < valueNum; i++) + { + + //ֳ + int arcticNum = 0; + char ** arctics = new char *[64]; + + //ַָ + split(values[i], "/", arctics, &arcticNum); + + if(strstr(arctics[0],arctic) == NULL) + { + continue; + } + + int num = 0; + char ** nodeUsers = new char *[64]; + + printf("ַ%s\n", arctics[1]); + //ַָ + split(arctics[1], "-", nodeUsers, &num); + + printf("ַ0%s\n", nodeUsers[0]); + printf("ַ1%s\n", nodeUsers[1]); + + + + //EPM_ask_taskṣ״̬أ,ѿʼ + ITKCALL( EPM_ask_tasks(process,EPM_started, &cnt_task, &tasks )); + //EPM_assign_responsible_partyηηûҲԴ, + printf("%d+++++++++++++++++++++++++++\n",cnt_task); + for( int k = 0; k < cnt_task; k++ ) + { + //̽ڵ + ITKCALL( EPM_ask_name( tasks[k] , tmp_sub_task_name )); + + printf("̽ڵƣ%s+++++++++++++++++++++++++++\n",tmp_sub_task_name); + + ////̽ڵ + /*ITKCALL( AOM_ask_value_string( tasks[k] , "object_type" , &sub_task_object_type )); + printf("̽ڵ%s=====================\n",sub_task_object_type);*/ + + if(strcmp(tmp_sub_task_name,nodeUsers[0]) == 0) + { + //ƻȡ + ITKCALL( EPM_ask_sub_task( tasks[k] , EPM_select_signoff_team_task , &tmp_select_signoff_task )); + + if(strstr(nodeUsers[1],",") != NULL) + { + char ** userIds = new char *[64]; + int userIdNum = 0; + + split(nodeUsers[1], ",", userIds, &userIdNum); + + for (int l = 0; l < userIdNum; l++) + { + tag_t user = NULLTAG; + ITKCALL( SA_find_user(userIds[l],&user)); + + ITKCALL( EPM_create_adhoc_signoff( tmp_select_signoff_task , user , &signoff_cnt , &signoffs ) ); + } + userIds = NULL; + + } + else + { + tag_t user = NULLTAG; + ITKCALL( SA_find_user(nodeUsers[1],&user)); + + ITKCALL( EPM_create_adhoc_signoff( tmp_select_signoff_task , user , &signoff_cnt , &signoffs ) ); + } + + ITKCALL( EPM_set_adhoc_signoff_selection_done( tmp_select_signoff_task , true ) ); + ITKCALL(EPM_trigger_action(tmp_select_signoff_task,EPM_complete_action, "")); + DOFREE( signoffs ); + } + } + + + //EPM_ask_taskṣ״̬أȴе + ITKCALL( EPM_ask_tasks(process,EPM_pending, &cnt_task, &tasks )); + //EPM_assign_responsible_partyηηûҲԴ, + printf("%d+++++++++++++++++++++++++++\n",cnt_task); + for( int k = 0; k < cnt_task; k++ ) + { + //̽ڵ + ITKCALL( EPM_ask_name( tasks[k] , tmp_sub_task_name )); + + printf("̽ڵƣ%s+++++++++++++++++++++++++++\n",tmp_sub_task_name); + + ////̽ڵ + /*ITKCALL( AOM_ask_value_string( tasks[k] , "object_type" , &sub_task_object_type )); + printf("̽ڵ%s=====================\n",sub_task_object_type);*/ + + if(strcmp(tmp_sub_task_name,nodeUsers[0]) == 0) + { + //ƻȡ + ITKCALL( EPM_ask_sub_task( tasks[k] , EPM_select_signoff_team_task , &tmp_select_signoff_task )); + + if(strstr(nodeUsers[1],",") != NULL) + { + char ** userIds = new char *[64]; + int userIdNum = 0; + + split(nodeUsers[1], ",", userIds, &userIdNum); + + for (int l = 0; l < userIdNum; l++) + { + tag_t user = NULLTAG; + ITKCALL( SA_find_user(userIds[l],&user)); + + ITKCALL( EPM_create_adhoc_signoff( tmp_select_signoff_task , user , &signoff_cnt , &signoffs ) ); + } + userIds = NULL; + + } + else + { + tag_t user = NULLTAG; + ITKCALL( SA_find_user(nodeUsers[1],&user)); + + ITKCALL( EPM_create_adhoc_signoff( tmp_select_signoff_task , user , &signoff_cnt , &signoffs ) ); + } + + ITKCALL( EPM_set_adhoc_signoff_selection_done( tmp_select_signoff_task , true ) ); + + + //ITKCALL(EPM_trigger_action(tmp_select_signoff_task,EPM_complete_action, "")); + DOFREE( signoffs ); + } + } + nodeUsers = NULL; + arctics = NULL; + } + + DOFREE( values ); + DOFREE( processUser ); + DOFREE( arctic ); + DOFREE( tasks ); + printf("==================ָԱ END =======================\n"); + + return ITK_ok; +} + + +int nodecount = 0; +int userinfoscount = 0; +int timeinfoscount = 0; + +typedef struct{ + string TaskUserName; + string TaskTimeName; + string UserName; + string TimeStr; + string GroupName; + string PropUserName; + string PropTimeName; +}NOTICE_NODE; + +//ԱϢ +struct USERINFOS +{ + char taskname[128]; + char propertyname[128]; + char group[128]; +}userinfo_s[64]; + +//Ϣ +struct TIMEINFOS +{ + char taskname[128]; + char propertyname[128]; + char group[128]; +}timeinfo_s[64]; + +void Split( string strArg, string spliter, vector &ans ) +{ + ans.clear(); + size_t index0; + string one_arg; + if ( strArg.find_first_not_of(' ') == string::npos ) + strArg = ""; + while( strArg.size()>0 ) + { + index0 = strArg.find(spliter); + if( index0 != string::npos ) + { + one_arg = strArg.substr( 0, index0 ); + strArg = strArg.substr( index0 + spliter.size() ); + ans.push_back( one_arg ); + } + else + { + ans.push_back( strArg ); + break; + } + } +} + +/** +* +* Description: +* This handler will set signoff infomation to properties of form +* +* Syntax: +* jf-sign-tongzhi [-debug=true|false] +* +* -SignUserName: =c7Formation;=c7Design;=c7Review +* +* -SignDate: =c7Formationtime;У=c7DesignTime;=c7ReviewTime +* +* -SignDateFormate: %Y-%m-%d +* +* -bypass +* +* -include_type Ҫǩı +* +*/ +int JL_sign_tongzhi(EPM_action_message_t msg) +{ + printf("======================================================\n"); + printf("ʼ֪ͨڵǩ\n"); + printf("======================================================\n"); + int ifail = ITK_ok ; + // + char arg1value[1024] = "",arg2value[1024] = "",arg3value[1024]="",arg4value[1024]="", + signcounter_info[1024] = "",include_type[1024]=""; + char *argflag =NULL,*argvalue=NULL ,*arg = NULL; + BOOL setboth = TRUE ,bypass; + int arg_cnt = 0; + + //̽ڵ + tag_t root_task = NULLTAG ,current_task = NULLTAG,type_tag = NULLTAG; + char tgt_type[WSO_name_size_c+1]="",type_class[TCTYPE_class_name_size_c+1]=""; + tag_t cur_task = NULLTAG; + char task_type[WSO_name_size_c+1] = ""; + int i=0, j=0, k=0, count = 0, n = 0; + tag_t itemrevision = NULLTAG,master_form_rel_type = NULLTAG; + int form_count = 0; + tag_t *form_list = NULL,master_form = NULLTAG; + char *prop_name="last_mod_date"; + + current_task = msg.task; + arg_cnt = TC_number_of_arguments(msg.arguments); + printf("Ϊ%d\n",arg_cnt); + if (arg_cnt > 0) + { + for (i=0;i include_type_vec; + vector signoff_name_info; + vector signoff_time_info; + vector notice_node_vec; + + Split(include_type,";",include_type_vec); + Split(arg1value,";",signoff_name_info); + Split(arg2value,";",signoff_time_info); + + if(signoff_name_info.size() != signoff_time_info.size()){ + printf("ǩ쳣\n"); + return 0; + } + + for(i = 0 ;i < signoff_name_info.size();i++){ + vector name_sub_vec; + vector tiem_sub_vec; + Split(signoff_name_info[i],"=",name_sub_vec); + Split(signoff_time_info[i],"=",tiem_sub_vec); + if(name_sub_vec.size()==2 && tiem_sub_vec.size() ==2 ){ + NOTICE_NODE node ; + node.TaskTimeName.assign(tiem_sub_vec[0]); + node.TaskUserName.assign(name_sub_vec[0]); + node.PropTimeName.assign(tiem_sub_vec[1]); + node.PropUserName.assign(name_sub_vec[1]); + notice_node_vec.push_back(node); + } + name_sub_vec.clear(); + tiem_sub_vec.clear(); + } + + ITKCALL( EPM_ask_root_task( msg.task, &root_task ) ); + + int valid_signoffs_count = 0; + tag_t * valid_signoffs_tags = NULL; + ITKCALL(AOM_ask_value_tags(msg.task,"valid_signoffs",&valid_signoffs_count,&valid_signoffs_tags)); + if(valid_signoffs_count !=0){ + for(int ii = 0 ;ii < valid_signoffs_count;ii++){ + date_t decision_date ; + char * decision_str = NULL; + char * assign_user_name = NULL; + char * group_name = NULL; + char * role_name = NULL; + char * timeinfo1 = NULL; + char * o_group_name = NULL; + tag_t assign_user = NULL_TAG; + tag_t assign_goup_mem = NULL_TAG; + tag_t role_tag = NULL_TAG; + tag_t o_group_tag = NULL_TAG; + //ȡʱ + AOM_ask_value_date(valid_signoffs_tags[ii],"decision_date",&decision_date); + // + AOM_UIF_ask_value(valid_signoffs_tags[ii],"decision",&decision_str); + printf("%s",decision_str); + //֪ͨ + AOM_ask_value_tag(valid_signoffs_tags[ii],"fnd0Assignee",&assign_user); + if(assign_user!=NULL_TAG){ + AOM_UIF_ask_value(assign_user,"user_name",&assign_user_name); + } + //֪ͨڵ + ITKCALL(AOM_ask_value_tag(valid_signoffs_tags[ii],"group_member",&assign_goup_mem)); + if(assign_goup_mem!=NULL_TAG){ + AOM_UIF_ask_value(assign_goup_mem,"object_name",&group_name); + //role_tag + AOM_ask_value_tag(assign_goup_mem,"role",&role_tag); + if(role_tag!= NULL_TAG){ + AOM_UIF_ask_value(role_tag,"object_name",&role_name); + } + AOM_ask_value_tag(assign_goup_mem,"group",&o_group_tag); + if(o_group_tag!= NULL_TAG){ + AOM_UIF_ask_value(o_group_tag,"name",&o_group_name); + } + + } + DATE_date_to_string(decision_date,arg3value,&timeinfo1); + printf("֪ͨˣ[%s] ֯[%s] ɫ[%s] ʱ䣺[%d-%d-%d] ״̬[%s]\n",assign_user_name,o_group_name,role_name,decision_date.year,decision_date.month,decision_date.day,decision_str); + + BOOL is_used = FALSE; + for( i = 0 ;i < notice_node_vec.size();i++){ + //string sign_task_name; + //sign_task_name.assign(notice_node_vec[i].TaskUserName.c_str()); + //string temp_task_name; + //temp_task_name.assign(group_name); + if(strcmp(role_name,notice_node_vec[i].TaskUserName.c_str())==0){ + printf("role_name = %s / TaskUserName = %s \n",role_name,notice_node_vec[i].TaskUserName.c_str()); + notice_node_vec[i].UserName.assign(assign_user_name); + notice_node_vec[i].TimeStr.assign(timeinfo1); + is_used = TRUE; + break; + }else if(strcmp(o_group_name,notice_node_vec[i].TaskUserName.c_str())==0){ + printf("group_name=%s / TaskUserName = %s \n",o_group_name,notice_node_vec[i].TaskUserName.c_str()); + notice_node_vec[i].UserName.assign(assign_user_name); + notice_node_vec[i].TimeStr.assign(timeinfo1); + is_used = TRUE; + break; + }else{ + printf("Other Group / TaskUserName = %s\n",notice_node_vec[i].TaskUserName.c_str()); + } + } + if(!is_used) + for( i = 0 ;i < notice_node_vec.size();i++){ + if(strcmp(notice_node_vec[i].TaskUserName.c_str(),"̼")==0){ + printf("group =̼ / TaskUserName = %s \n",notice_node_vec[i].TaskUserName.c_str()); + notice_node_vec[i].UserName.assign(assign_user_name); + notice_node_vec[i].TimeStr.assign(timeinfo1); + break; + } + } + + + if(decision_str!=NULL){ + MEM_free(decision_str); + decision_str = NULL; + } + if(assign_user_name!=NULL){ + MEM_free(assign_user_name); + assign_user_name = NULL; + } + if(group_name!=NULL){ + MEM_free(group_name); + group_name = NULL; + } + if(role_name!=NULL){ + MEM_free(role_name); + role_name = NULL; + } + if(timeinfo1!=NULL){ + MEM_free(timeinfo1); + timeinfo1 = NULL; + } + if(o_group_name!=NULL){ + MEM_free(o_group_name); + o_group_name = NULL; + } + } + } + + int occur_of_counts = 0; + tag_t * taskAttches =NULL; + printf("the node number is %d",nodecount); + if(current_task != NULLTAG) + { + EPM_ask_attachments(root_task, EPM_target_attachment, &occur_of_counts, &taskAttches); + printf("%d target attachment found",occur_of_counts); + for( count=0; count 0) + { + for (i=0;i type_vec; + + //Split(exclude_type,";",type_vec); + + printf("1%d\n",userinfoscount); + printf("2%d\n",timeinfoscount); + + //õhandlerĽڵ + msg.task; + //ͨڵȡ + EPM_ask_root_task( msg.task, &root_task ); + //õµеһڵ + EPM_ask_sub_tasks( root_task, &sub_task_count, &sub_tasks); + //õ̵ + EPM_ask_name( root_task, root_task_name ); + // + printf("root_task_name=%s\n",root_task_name); + EPM_ask_name( current_task, task_name ); + printf( "sub_task_count = %d\n", sub_task_count ); + +//test========================== + //tag_t user = NULLTAG, *tasks = NULL; + //int n_task= 0; + //ITKCALL(SA_find_user( "admin", &user )); + //ITKCALL(SA_ask_user_work_contexts ( user, &n_task, &tasks)); + //ECHO("==========n_task=%d",n_task); +//============================== + + //DOڵ + if(strcmp(task_name,"") == 0||strcmp(task_name,"") == 0) + { + printf("task_name:%s",task_name); + //ȡ + s = EPM_ask_responsible_party(current_task,&responsibleParty); + if(responsibleParty != NULLTAG) + { + decision = EPM_go; + } + //ȡǰû + s = POM_get_user(&userName,&aUserTag); + //ȡpersonname + SA_ask_user_person_name(aUserTag,person_name); + strcat(sign_info,task_name); + strcat(sign_info,"="); + strcat(sign_info,person_name); + strcat(sign_info,"|"); + strcat(sign_info,task_name); + strcat(sign_info,"="); + //POM_ask_v + //ȡʱԣ1󣬲2ƣ3ȡʱֵ + AOM_ask_value_date(current_task,prop_name,&decision_date); + //AOM_UIF_ask_value(current_task,prop_name, &timeinfo2); + //ʱṹתΪijʱʽַ + DATE_date_to_string(decision_date,arg3value,&timeinfo2); + printf("\n--------------\n timeinfo2=%s\n------------\n",timeinfo2); + strcat(sign_info,timeinfo2); + strcat(sign_info,"|"); + strcpy(flownode_s[nodecount].taskname,task_name); + strcpy(flownode_s[nodecount].username,person_name); + strcpy(flownode_s[nodecount].timeinfo,timeinfo2); + nodecount = nodecount + 1; + + } + else //performڵ + { + for(i=0;i cur_task_name = %s\n" , cur_task_name ); + + } + } + if(cur_perform_task != NULLTAG ) + { + if( strcmp( cur_task_name, "" ) == 0||strcmp( cur_task_name, "" ) == 0 ) + { + tag_t assign_user = NULL_TAG; + char * assign_user_name = NULL; + printf("task_name=%s",task_name); + s = EPM_ask_responsible_party(cur_perform_task,&responsibleParty); + if(responsibleParty != NULLTAG) + { + decision = EPM_go; + } + s = POM_get_user(&userName,&aUserTag); + SA_ask_user_person_name(aUserTag, person_name); + AOM_ask_value_tag(cur_perform_task,"fnd0Assignee",&assign_user); + if(assign_user!=NULL_TAG){ + AOM_UIF_ask_value(assign_user,"user_name",&assign_user_name); + } + strcat(output_str, cur_task_name); + strcat(output_str, "="); + //strcat(output_str, person_name); + strcat(output_str, assign_user_name); + strcat(output_str, "|"); + strcat(output_str, cur_task_name); + strcat(output_str, "="); + AOM_ask_value_date(cur_perform_task,prop_name,&decision_date); + DATE_date_to_string(decision_date,arg3value,&timeinfo1); + printf("\n-------\ntimeinfo 111 : %s\n------------\n",timeinfo1); + //ITK_date_to_string (decision_date, &timeinfo1); + strcat( output_str, timeinfo1 ); + strcat(output_str,"|"); + printf("timeinfo : %s",timeinfo1); + strcpy(flownode_s[nodecount].taskname,cur_task_name); + //strcpy(flownode_s[nodecount].username,person_name); + strcpy(flownode_s[nodecount].username,assign_user_name); + strcpy(flownode_s[nodecount].timeinfo,timeinfo1); + nodecount = nodecount + 1; + MEM_free(userName); + if(assign_user_name!=NULL){ + MEM_free(assign_user_name); + assign_user_name = NULL; + } + } + else + { + //˼ + tag_t owner = NULLTAG; + date_t date; + logical is_valid; + char *d_value = NULL; + //AOM_ask_owner( cur_perform_task, &owner); + //if( owner != NULLTAG ) + // SA_ask_user_person_name(owner, person_name); + //AOM_ask_value_date(cur_perform_task,"creation_date", &date);//fnd0StartDate + //DATE_date_to_string(date,arg3value,&d_value); + //ITKCALL(AOM_UIF_ask_value( cur_perform_task, "fnd0StartDate", &d_value)); + //ECHO("d_value : %s",d_value); + //strcat(output_str, ""); + //strcat(output_str, "="); + //strcat(output_str, person_name); + //strcat(output_str, "|"); + //strcat(output_str, "="); + //CALL(DATE_date_to_string(date,arg3value,&timeinfo)); + //ITKCALL(DATE_string_to_date_t(d_value, &is_valid,&date)); + //CALL(DATE_date_to_string(date,arg3value,&timeinfo)); + //ECHO("timeinfo : %s",timeinfo); + //vector ans; + //if( d_value != NULL ) + //{ + // Split(d_value, ' ', ans); + // if(ans.size() > 1) + // strcat(output_str,ans[0].c_str()); + //} + //strcat(output_str,d_value); + //DOFREE(timeinfo); + //strcat(output_str, "|"); + // strcpy(flownode_s[nodecount].taskname,""); + // strcpy(flownode_s[nodecount].username,person_name); + //if(ans.size() > 1) + // strcpy(flownode_s[nodecount].timeinfo,d_value); + // nodecount = nodecount + 1; + //ECHO("output_str=%s",output_str); + EPM_ask_all_attachments(cur_perform_task,&perform_count,&perform_attaches,&attach_type); + printf("EPM_signoff_attachment Counts = %d", perform_count); + + for(i=0;i 0) + { + for (int i=0;i> itemMap; + + ITKCALL(AOM_ask_value_tag(root_task, "owning_user", &attOwning_user)); + AOM_ask_value_string(attOwning_user, "user_name", &nmae); + //ȡ + SA_ask_user_login_group(attOwning_user,&group); + + //ȡ + for (int i = 0; i < count; i++) + { + //ȡѡ + PREF_ask_char_values("JL_CreateProcess", &valueNum, &values);//ѡ + + int form_count; + char * itemType = NULL, * type = NULL,*jcjwlh = NULL; + tag_t master_form_rel_type = NULLTAG, * form_list = NULLTAG; + + AOM_ask_value_string(attachments[i], "object_type", &itemType); + + printf("type_class : %s \r\n", itemType); + //˵ǰ汾Ķ + if((strstr(itemType,"Revision") == NULL) || (strstr(itemType,"Master") != NULL) + || (strstr(itemType,"master") != NULL) || (strstr(itemType,"BOM") != NULL) || (strstr(itemType,"bom") != NULL) || (strstr(itemType,"Bom") != NULL)) + { + continue; + } + //ƷҪ汾 + if (strcmp(itemType,"Gd6_CPYQRevision")==0 || strcmp(itemType,"WeldPointRevision")==0) { + continue; + } + if(!(strcmp("Gd6_PartsRevision", itemType) == 0 || strcmp("Gd6_VehicleRevision", itemType) == 0 + || strcmp("Gd6_XZMKCRevision", itemType) == 0 || strcmp("Gd6_BZJRevision", itemType) == 0 + || strcmp("Gd6_PTJRevision", itemType) == 0)){ + continue; + + } + + //ȡ汾 + GRM_find_relation_type( TC_master_form_rtype, &master_form_rel_type ); + GRM_list_secondary_objects_only(attachments[i], master_form_rel_type, &form_count, &form_list ); + if( form_count ==0 ) + { + printf("δҵform,..."); + continue; + } + AOM_ask_value_string(form_list[0], "gd6_wlfl", &type); + AOM_ask_value_string(form_list[0], "gd6_jcjwlh", &jcjwlh); + + //жϷ汾ĶǷΨһ汾ϰ汾жϸð汾ϷǷһ汾һ£ + //һ£贴SAPά̣һ£贴 + tag_t item = NULLTAG,*revisions; + ITEM_ask_item_of_rev(attachments[i],&item); + int rev_count = 0; + ITEM_find_revisions(item,"*",&rev_count,&revisions); + printf("汾Ϊ:%d",rev_count); + if(rev_count > 1){ + tag_t old_rev = revisions[rev_count-2],*old_form_list = NULLTAG; + //ȡһ汾ı + int old_form_count = 0; + char *old_type = NULL,*old_jcjwlh = NULL; + tag_t old_form_rel_type = NULLTAG; + GRM_find_relation_type( TC_master_form_rtype, &old_form_rel_type ); + GRM_list_secondary_objects_only(old_rev, old_form_rel_type, &old_form_count, &old_form_list ); + if( old_form_count == 0 ) + { + printf("δҵform,..."); + continue; + } + AOM_ask_value_string(old_form_list[0], "gd6_wlfl", &old_type); + AOM_ask_value_string(old_form_list[0], "gd6_jcjwlh", &old_jcjwlh); + if(strcmp(type,old_type) == 0 || strcmp(jcjwlh,old_jcjwlh) == 0){ + //汾Ϸһ + continue; + } + } + + //鿴ǷͶӦģ + for (int j = 0; j < valueNum; j++) + { + printf("%sв%s\n",values[j],type); + + if(type != NULL && strcmp(type, "") != 0 && type != "" && strstr(values[j],type) != NULL) + { + int arcticNum = 0; + //char * typeValues = { 0 }; + char ** arctics = new char *[64]; + //strcpy(typeValues,values[j]); + //strcat(typeValues, values[j]); + + split(values[j], "=", arctics, &arcticNum); + //map>::iterator iteFind = itemMap.find(arctics[0]); + //鿴ǷMap + if(itemMap.count(arctics[0]) == 0) + { + printf("%s...%s\n",type,arctics[0]); + vector itemVector; + itemVector.push_back(attachments[i]); + itemMap[arctics[0]] = itemVector; + } + else + { + printf("%s...%s\n",type,arctics[0]); + vector itemVector = itemMap[arctics[0]]; + itemVector.push_back(attachments[i]); + itemMap[arctics[0]] = itemVector; + } + + arctics = NULL; + } + else + { + printf("δҵ\n"); + } + + //if(strcmp(type,"H21")==0||strcmp(type,"H22")==0){ + // for (int n = 0; n < count; n++){ + // int arcticNum = 0; + // //char * typeValues = { 0 }; + // char ** arctics = new char *[64]; + // //strcpy(typeValues,values[j]); + // //strcat(typeValues, values[j]); + + // split(values[j], "=", arctics, &arcticNum); + // //map>::iterator iteFind = itemMap.find(arctics[0]); + // //鿴ǷMap + // if(itemMap.count(arctics[0]) == 0) + // { + // printf("%s...%s\n",type,arctics[0]); + // vector itemVector; + // itemVector.push_back(referenceItem[n]); + // itemMap[arctics[0]] = itemVector; + // } + // else + // { + // printf("%s...%s\n",type,arctics[0]); + // vector itemVector = itemMap[arctics[0]]; + // itemVector.push_back(referenceItem[n]); + // itemMap[arctics[0]] = itemVector; + // } + + // arctics = NULL; + // } + //} + + } + values = NULL; + } + + //MAP + map>::iterator ite = itemMap.begin(); + + for(ite; ite != itemMap.end(); ite++) + { + string processTemp = (*ite).first; + vector itemVector = (*ite).second; + int size = itemVector.size(); + + printf("ID%sӦ%d\n",processTemp.c_str(),size); + + ITKCALL( EPM_find_template( processTemp.c_str(), PROCESS_TEMPLATE, &template_tag) ); + + int *tagType=(int *)MEM_alloc(1024 * sizeof(int)); + tag_t * itemTag = (tag_t *)MEM_alloc(1024 * sizeof(tag_t)); + + for(auto k=0;k=count){ + // tagType[k] = EPM_target_attachment; + //} + //else{ + // tagType[k] = EPM_reference_attachment; + //} + tagType[k] = EPM_target_attachment; + itemTag[k] = itemVector[k]; + } + //boolean condition = true; + //if(strstr(processTemp.c_str(),"H21")!=NULL||strstr(processTemp.c_str(),"H22")!=NULL){ + // printf("븽\n"); + // condition = false; + // for(int n=0;n +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include +#include +#include + +#include +#include +#include +#pragma comment(lib, "ws2_32.lib") + +using namespace std; + +#define DOFREE(obj) \ +{ \ + if(obj) \ + { \ + MEM_free(obj); \ + obj = NULL; \ + } \ +} + +struct Base64Date6 +{ + unsigned int d4 : 6; + unsigned int d3 : 6; + unsigned int d2 : 6; + unsigned int d1 : 6; +}; + +// Эмܲʹõbase64 +char ConvertToBase64(char c6); +void EncodeBase64(char *dbuf, char *buf128, int len); +void SendMail(char *email, char *body, char * server_address, int port, char * from_email, char * password); +int OpenSocket(struct sockaddr *addr); + +////////////////////////////////////////////////////////////////////////////////// + +//JL_current_touser_mail_address + + +int JL_Send_Mail(EPM_action_message_t msg) +{ + printf("ʼִ======JL_Send_Mail\n"); + + int ifail = ITK_ok; + tag_t root_task = NULLTAG; + tag_t * attachments = NULLTAG; + int count = 0; + char * ProcessOwner = NULL; + tag_t process_assignee_user = NULLTAG; + tag_t process_assignee_person = NULL_TAG; + tag_t default_group = NULL_TAG; + char * group = NULL; + date_t process_creation_date; + + ::CoInitialize(NULL); //ʼOLE/COM⻷ + HRESULT hr = NULL; + _ConnectionPtr m_pConnection; // ݿ + _RecordsetPtr m_pRecordset; // + _CommandPtr m_pCommand; // ¼ + + //ʼ + char *EmailTo = NULL; + //char serverAddress[] = ""; + char * server_address = NULL; + int port = 25; + char * from_email = ""; + char * password = ""; + char * port_string = NULL; + char * ChangeType = NULL; + char * ChangeTheOddNumber = NULL; + char EmailContents[5120] = ""; + char EmailTo1[5120] = ""; + //ȡѡ + int valueNum = 0; + int toEmailNum = 0; + char ** to_email = NULL; + //PREF_ask_char_value("JL_current_user_server_address", valueNum, &server_address); + PREF_ask_char_value("JL_current_user_server_address_port", valueNum, &port_string); + PREF_ask_char_value("JL_current_user_mail_password", valueNum, &password); + PREF_ask_char_value("JL_current_user_mail_address", valueNum, &from_email); + PREF_ask_char_values("JL_current_touser_mail_address", &toEmailNum, &to_email); + + + PREF_ask_char_value("TC11_SqlServer_Link_ITK", valueNum, &server_address); + + printf("JL_current_user_server_address%s=======================\n", server_address); + port = atoi(port_string); + //ȡid + char all_ID[5120] = ""; + char all_ID_name[512] = ""; + char partName[512] = ""; + EPM_ask_root_task(msg.task, &root_task); + EPM_ask_attachments(root_task, EPM_target_attachment, &count, &attachments); + for (int i = 0; i < count; i++) { + char * item_id, *object_name, *itemType = NULL; + + AOM_ask_value_string(attachments[i], "object_type", &itemType); + printf("type_class : %s \r\n", itemType); + + //˵ǰ汾Ķ + if((strstr(itemType,"Revision") == NULL) || (strstr(itemType,"Master") != NULL) + || (strstr(itemType,"master") != NULL) || (strstr(itemType,"BOM") != NULL) || (strstr(itemType,"bom") != NULL) || (strstr(itemType,"Bom") != NULL)) + { + continue; + } + if(strstr(itemType,"ChangeRevision") == NULL){ + continue; + } + + AOM_ask_value_string(attachments[i], "item_id", &item_id); + AOM_ask_value_string(attachments[i], "object_name", &object_name); + sprintf_s(all_ID, "%s ", item_id); + sprintf_s(all_ID_name, "%s,%s ", item_id, object_name); + + int relation_num = 0; + tag_t * C8RelationModification = NULLTAG; + //ȡ㲿㲿µĶ + AOM_ask_value_tags(attachments[i], "Gd6_BGLBJ", &relation_num, &C8RelationModification); + for (int j = 0; j < relation_num; j++) + { + AOM_ask_value_string(C8RelationModification[j], "item_id", &item_id); + AOM_ask_value_string(C8RelationModification[j], "object_name", &object_name); + + sprintf_s(partName, "%s㲿ID%s-ƣ%s\n ",partName, item_id, object_name, ""); + } + AOM_ask_value_tags(attachments[i], "Gd6_XGFJ", &relation_num, &C8RelationModification); + for (int j = 0; j < relation_num; j++) + { + AOM_ask_value_string(C8RelationModification[j], "item_id", &item_id); + AOM_ask_value_string(C8RelationModification[j], "object_name", &object_name); + + sprintf_s(partName, "%s㲿ID%s-ƣ%s\n ",partName, item_id, object_name, ""); + } + + DOFREE(item_id); + DOFREE(object_name); + DOFREE(itemType); + DOFREE(C8RelationModification); + + } + printf("all_ID%s=======================\n", all_ID); + printf("all_ID_name%s=======================\n", all_ID_name); + + //ȡ(͡) + TC_argument_list_t * arguments = msg.arguments; + int arg_cnt = TC_number_of_arguments(arguments); + printf("TC_number_of_arguments %d\n", arg_cnt); + char * arg = NULL, *temp_key = NULL, *temp_val = NULL; + for (int ii = 0; iiConnectionString = (server_address); + printf("\n==========================================================\n"); + hr = m_pConnection->Open("", "", "", adConnectUnspecified);//ݿ + if (FAILED(hr)) + { + printf("Open Failed!"); + return 1; + } + + for (int j = 0; j < valid_signoffs_count; j++) + { + printf("ʼִз++++++++\n"); + char * assign_user_name = NULL; + tag_t assign_user = NULL_TAG; + tag_t person = NULL_TAG; + tag_t Email = NULL_TAG; + // + AOM_ask_value_tag(valid_signoffs_tags[j], "fnd0Assignee", &assign_user); + if (assign_user != NULL_TAG) + { + AOM_UIF_ask_value(assign_user, "user_name", &assign_user_name); + AOM_ask_value_tag(assign_user, "person", &person); + AOM_ask_value_string_at(person, "PA9", 0, &EmailTo); + strcpy_s(EmailTo1, EmailTo); + //strncpy(1,2,3); 2гΪ3ַ1 + strncpy_s(EmailTo1, EmailTo, strlen(EmailTo1) - 2); + //sprintf_s(EmailContents, "From: \"%s\"<%s>\r\n To: \"%s\"<%s>\r\n Subject: %s %s ֪ͨ%s\r\n\r\n %s\nã%s()%s(Ա)%s %s%s%sʽЧΪ%s\nڽڵ¼TeamcenterϵͳľϢ\n·ΪҵĹб->鿴Ҫִеµĸ", + //ProcessOwner, from_email, assign_user_name, EmailTo, all_ID, ChangeType, ChangeTheOddNumber, assign_user_name, group, ProcessOwner, all_ID, all_ID_name, ChangeType, date_string, partName); + sprintf_s(EmailContents, + /*"From: \"%s\"<%s>\r\n" + "To: \"%s\"<%s>\r\n" + "Subject: %s %s ֪ͨ%s\r\n\r\n"*/ + "%s\nã%s()%s(Ա)%s %s%s%sΪ%s" + "\n%s" + "\nڽڵ¼TeamcenterϵͳľϢ" + "\n·Ϊ->鿴µĸ", + //ProcessOwner, from_email, assign_user_name, EmailTo, all_ID, ChangeType, ChangeTheOddNumber, + assign_user_name, + group, ProcessOwner, all_ID, all_ID_name, ChangeType, ChangeTheOddNumber, all_ID,partName + ); + cout<< EmailContents<Execute(_bstr_t(describe), 0, adCmdText); + //return 1;//м䲻ֱӷصڴͷŴ + } + catch(_com_error e) + { + printf(e.Description()); + //return 0; + } + + describe = NULL; + + //SendMail(EmailTo, EmailContents, server_address, port, from_email, password); + } + printf("ִзɡ+++++++\n"); + } + + } + + } + + //for (int i = 0; i < toEmailNum; i++) + //{ + // char ** userEmail = new char *[64]; + // int userEmailNum = 0; + // split(to_email[i],"-",userEmail,&userEmailNum); + + // if(userEmailNum = 2) + // { + //sprintf_s(EmailContents, "From: \"%s\"<%s>\r\n" + // "To: \"%s\"<%s>\r\n" + // "Subject: %s %s ֪ͨ%s\r\n\r\n" + // "%s\nã%s()%s(Ա)%s %s%s%sΪ%s" + // "\n%s" + // "\nڽڵ¼TeamcenterϵͳľϢ" + // "\n·ΪҵĹб->鿴Ҫִеµĸ", + // ProcessOwner, from_email, userEmail[0], EmailTo, all_ID, ChangeType, ChangeTheOddNumber, userEmail[0], + // group, ProcessOwner, all_ID, all_ID_name, ChangeType, ChangeTheOddNumber, all_ID,partName + //); + + // printf("EmailTo%s\n EmailContents%s\n server_address%s\n port%d\n from_email%s\n password%s\n", EmailTo, EmailContents, server_address, port, from_email, password); + // SendMail(userEmail[1], EmailContents, server_address, port, from_email, password); + // printf("ˣ%s=======================\n", EmailContents); + // printf("ˣ%=======================\n", userEmail[0]); + // printf("ʼַ%s=======================\n", userEmail[1]); + // //ƴӸ + // sprintf_s(assign_users, "%s%s,", assign_users, userEmail[0], ""); + // } + // for (int j = 0; j < userEmailNum; j++) + // { + // userEmail[j] = NULL; + // } + // userEmail = NULL; + //} + + //qilong.lu@xmgdab.com + + + //cout <<"aaaaaaaaaaaaaa"+valid_signoffs_count <\r\n To: \"%s\"<%s>\r\n Subject: %s %s ֪ͨ%s\r\n\r\n %s\nã%s()%s(Ա)%s %s%s%sʽЧΪ%s\nڽڵ¼TeamcenterϵͳľϢ\n·ΪҵĹб->鿴Ҫִеµĸ", + // ProcessOwner, from_email, assign_user_name, EmailTo, all_ID, ChangeType, ChangeTheOddNumber, assign_user_name, group, ProcessOwner, all_ID, all_ID_name, ChangeType, date_string, ChangeTheOddNumber); + // + // } + // printf("ִзɡ+++++++"); + // } + //} + DOFREE(attachments); + DOFREE(ProcessOwner); + DOFREE(group); + DOFREE(EmailTo); + DOFREE(server_address); + DOFREE(from_email); + DOFREE(password); + DOFREE(port_string); + DOFREE(ChangeType); + DOFREE(ChangeTheOddNumber); + //DOFREE(arguments); + arg = NULL; + DOFREE(temp_key); + temp_val = NULL; + DOFREE(date_string); + for (int i = 0; i < toEmailNum; i++) + { + to_email[i] = NULL; + } + to_email = NULL; + //DOFREE(valid_signoffs_tags); + //10.1.100.4 + //printf("ڵѡе=======================================%s\n", assign_users); + + printf("ִн======JL_Send_Mail\n"); + //SendMail(EmailTo, EmailContents, serverAddress, port, from_email, password);*/ + return ifail; + +} + + +///////////////////////////////////////////////////////////////////////// + +char ConvertToBase64(char uc) +{ + if (uc < 26) + { + return 'A' + uc; + } + if (uc < 52) + { + return 'a' + (uc - 26); + } + if (uc < 62) + { + return '0' + (uc - 52); + } + if (uc == 62) + { + return '+'; + } + return '/'; +} + +// base64ʵ +void EncodeBase64(char *dbuf, char *buf128, int len) +{ + struct Base64Date6 *ddd = NULL; + int i = 0; + char buf[256] = { 0 }; + char *tmp = NULL; + char cc = '\0'; + + memset(buf, 0, 256); + strcpy_s(buf, 256, buf128); + for (i = 1; i <= len / 3; i++) + { + tmp = buf + (i - 1) * 3; + cc = tmp[2]; + tmp[2] = tmp[0]; + tmp[0] = cc; + ddd = (struct Base64Date6 *)tmp; + dbuf[(i - 1) * 4 + 0] = ConvertToBase64((unsigned int)ddd->d1); + dbuf[(i - 1) * 4 + 1] = ConvertToBase64((unsigned int)ddd->d2); + dbuf[(i - 1) * 4 + 2] = ConvertToBase64((unsigned int)ddd->d3); + dbuf[(i - 1) * 4 + 3] = ConvertToBase64((unsigned int)ddd->d4); + } + if (len % 3 == 1) + { + tmp = buf + (i - 1) * 3; + cc = tmp[2]; + tmp[2] = tmp[0]; + tmp[0] = cc; + ddd = (struct Base64Date6 *)tmp; + dbuf[(i - 1) * 4 + 0] = ConvertToBase64((unsigned int)ddd->d1); + dbuf[(i - 1) * 4 + 1] = ConvertToBase64((unsigned int)ddd->d2); + dbuf[(i - 1) * 4 + 2] = '='; + dbuf[(i - 1) * 4 + 3] = '='; + } + if (len % 3 == 2) + { + tmp = buf + (i - 1) * 3; + cc = tmp[2]; + tmp[2] = tmp[0]; + tmp[0] = cc; + ddd = (struct Base64Date6 *)tmp; + dbuf[(i - 1) * 4 + 0] = ConvertToBase64((unsigned int)ddd->d1); + dbuf[(i - 1) * 4 + 1] = ConvertToBase64((unsigned int)ddd->d2); + dbuf[(i - 1) * 4 + 2] = ConvertToBase64((unsigned int)ddd->d3); + dbuf[(i - 1) * 4 + 3] = '='; + } + return; +} +// ʼ email:Ŀ body: server_address:smtpַ port:˿ from_email:û password:롢Ȩ +void SendMail(char *email, char *body, char * server_address, int port, char * from_email, char * password) +{ + int sockfd = { 0 }; + char buf[1500] = { 0 }; + char rbuf[1500] = { 0 }; + char login[128] = { 0 }; + char pass[128] = { 0 }; + WSADATA WSAData; + struct sockaddr_in their_addr = { 0 }; + WSAStartup(MAKEWORD(2, 2), &WSAData); + memset(&their_addr, 0, sizeof(their_addr)); + + their_addr.sin_family = AF_INET; + their_addr.sin_port = htons(port); + hostent* hptr = gethostbyname(server_address); + memcpy(&their_addr.sin_addr.S_un.S_addr, hptr->h_addr_list[0], hptr->h_length); + printf("IP of %s is : %d:%d:%d:%d\n", server_address, + their_addr.sin_addr.S_un.S_un_b.s_b1, + their_addr.sin_addr.S_un.S_un_b.s_b2, + their_addr.sin_addr.S_un.S_un_b.s_b3, + their_addr.sin_addr.S_un.S_un_b.s_b4); + + // ʼӺûӦ2 + sockfd = OpenSocket((struct sockaddr *)&their_addr); + memset(rbuf, 0, 1500); + while (recv(sockfd, rbuf, 1500, 0) == 0) + { + cout << "reconnect..." << endl; + Sleep(2); + sockfd = OpenSocket((struct sockaddr *)&their_addr); + memset(rbuf, 0, 1500); + } + + cout << rbuf << endl; + + // EHLO + memset(buf, 0, 1500); + sprintf_s(buf, 1500, "EHLO HYL-PC\r\n"); + send(sockfd, buf, strlen(buf), 0); + memset(rbuf, 0, 1500); + recv(sockfd, rbuf, 1500, 0); + cout << "EHLO REceive: " << rbuf << endl; + + // AUTH LOGIN + memset(buf, 0, 1500); + sprintf_s(buf, 1500, "AUTH LOGIN\r\n"); + send(sockfd, buf, strlen(buf), 0); + memset(rbuf, 0, 1500); + recv(sockfd, rbuf, 1500, 0); + cout << "Auth Login Receive: " << rbuf << endl; + + // USER + memset(buf, 0, 1500); + sprintf_s(buf, 1500, from_email);//˺ + memset(login, 0, 128); + EncodeBase64(login, buf, strlen(buf)); + sprintf_s(buf, 1500, "%s\r\n", login); + send(sockfd, buf, strlen(buf), 0); + cout << "Base64 UserName: " << buf << endl; + memset(rbuf, 0, 1500); + recv(sockfd, rbuf, 1500, 0); + cout << "User Login Receive: " << rbuf << endl; + + // PASSWORD + sprintf_s(buf, 1500, password);// + memset(pass, 0, 128); + EncodeBase64(pass, buf, strlen(buf)); + sprintf_s(buf, 1500, "%s\r\n", pass); + send(sockfd, buf, strlen(buf), 0); + cout << "Base64 Password: " << buf << endl; + + memset(rbuf, 0, 1500); + recv(sockfd, rbuf, 1500, 0); + cout << "Send Password Receive: " << rbuf << endl; + + // MAIL FROM + memset(buf, 0, 1500); + sprintf_s(buf, 1500, "MAIL FROM: <%s>\r\n", from_email); + send(sockfd, buf, strlen(buf), 0); + memset(rbuf, 0, 1500); + recv(sockfd, rbuf, 1500, 0); + cout << "set Mail From Receive: " << rbuf << endl; + + // RCPT TO һռ + sprintf_s(buf, 1500, "RCPT TO:<%s>\r\n", email); + send(sockfd, buf, strlen(buf), 0); + memset(rbuf, 0, 1500); + recv(sockfd, rbuf, 1500, 0); + cout << "Tell Sendto Receive: " << rbuf << endl; + // DATA ׼ʼʼ + sprintf_s(buf, 1500, "DATA\r\n"); + send(sockfd, buf, strlen(buf), 0); + memset(rbuf, 0, 1500); + recv(sockfd, rbuf, 1500, 0); + cout << "Send Mail Prepare Receive: " << rbuf << endl; + + // ʼݣ\r\n.\r\nݽ + sprintf_s(buf, 1500, "%s\r\n.\r\n", body); + send(sockfd, buf, strlen(buf), 0); + memset(rbuf, 0, 1500); + recv(sockfd, rbuf, 1500, 0); + cout << "Send Mail Receive: " << rbuf << endl; + + // QUIT + sprintf_s(buf, 1500, "QUIT\r\n"); + send(sockfd, buf, strlen(buf), 0); + memset(rbuf, 0, 1500); + recv(sockfd, rbuf, 1500, 0); + cout << "Quit Receive: " << rbuf << endl; + + // + closesocket(sockfd); + WSACleanup(); + return; +} +// TCP Socket +int OpenSocket(struct sockaddr *addr) +{ + int sockfd = 0; + sockfd = socket(PF_INET, SOCK_STREAM, 0); + if (sockfd < 0) + { + cout << "Open sockfd(TCP) error!" << endl; + exit(-1); + } + if (connect(sockfd, addr, sizeof(struct sockaddr)) < 0) + { + cout << "Connect sockfd(TCP) error!" << endl; + exit(-1); + } + return sockfd; +} + + + diff --git a/CONNOR_ITK/JL_Send_Order_Process.cxx b/CONNOR_ITK/JL_Send_Order_Process.cxx new file mode 100644 index 0000000..42c3dcd --- /dev/null +++ b/CONNOR_ITK/JL_Send_Order_Process.cxx @@ -0,0 +1,229 @@ +#define _CRT_SECURE_NO_WARNINGS +#include "epm_handler_common.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include +#import "C:\Program Files\Common Files\System\ado\msado15.dll" no_namespace rename("EOF","adoEOF")rename("BOF","adoBOF") + +using namespace std; + +#define DOFREE(obj) \ +{ \ + if(obj) \ + { \ + MEM_free(obj); \ + obj = NULL; \ + } \ +} + +int Send_Order_Process(void *returnValue){ + printf("================== START =======================\n"); + + //ȡݹIJ + tag_t process = NULLTAG, tmp_select_signoff_task = NULLTAG, template_tag = NULLTAG; + int cnt_task = 0, signoff_cnt = 0; + tag_t * tasks = NULLTAG, * signoffs = NULLTAG; + char * processUser = NULL, * arctic = NULL; + char tmp_sub_task_name[WSO_name_size_c+1] = {'\0'}; + + ITKCALL(USERARG_get_tag_argument(&process)); + //ITKCALL(USERARG_get_tag_argument(&itemRevision)); + //ITKCALL(USERARG_get_string_argument(&processTemplate)); + ITKCALL(USERARG_get_string_argument(&processUser)); + // + ITKCALL(USERARG_get_string_argument(&arctic)); + + //// + ////ģEPM_find_templateģƣģͣģ + //ITKCALL( EPM_find_template( processTemplate, PROCESS_TEMPLATE, &template_tag) ); + + //printf("ȡģɹ!================\n"); + + //ȡѡֵ + + //printf("==================ȡѡֵ =======================\n"); + //PREF_ask_char_values(processUser, &valueNum, &values);//ѡ + + //EPM_ask_taskṣ״̬أ,ѿʼ + ITKCALL( EPM_ask_tasks(process,EPM_started, &cnt_task, &tasks )); + //EPM_assign_responsible_partyηηûҲԴ, + printf("%d+++++++++++++++++++++++++++\n",cnt_task); + for( int k = 0; k < cnt_task; k++ ) + { + //̽ڵ + ITKCALL( EPM_ask_name( tasks[k] , tmp_sub_task_name )); + + printf("̽ڵƣ%s+++++++++++++++++++++++++++\n",tmp_sub_task_name); + + ////̽ڵ + /*ITKCALL( AOM_ask_value_string( tasks[k] , "object_type" , &sub_task_object_type )); + printf("̽ڵ%s=====================\n",sub_task_object_type);*/ + + //if(strcmp(tmp_sub_task_name,nodeUsers[0]) == 0) + //{ + //ƻȡ + ITKCALL( EPM_ask_sub_task( tasks[k] , EPM_select_signoff_team_task , &tmp_select_signoff_task )); + + /*if(strstr(nodeUsers[1],",") != NULL) + { + char ** userIds = new char *[64]; + int userIdNum = 0; + + split(nodeUsers[1], ",", userIds, &userIdNum); + + for (int l = 0; l < userIdNum; l++) + { + tag_t user = NULLTAG; + ITKCALL( SA_find_user(userIds[l],&user)); + + ITKCALL( EPM_create_adhoc_signoff( tmp_select_signoff_task , user , &signoff_cnt , &signoffs ) ); + } + userIds = NULL; + + } + else + { + tag_t user = NULLTAG; + ITKCALL( SA_find_user(nodeUsers[1],&user)); + + ITKCALL( EPM_create_adhoc_signoff( tmp_select_signoff_task , user , &signoff_cnt , &signoffs ) ); + }*/ + + tag_t user = NULLTAG; + if(strcmp(tmp_sub_task_name,"") == 0){ + ITKCALL( SA_find_user(processUser,&user)); + + ITKCALL( EPM_create_adhoc_signoff( tmp_select_signoff_task , user , &signoff_cnt , &signoffs ) ); + + ITKCALL( EPM_set_adhoc_signoff_selection_done( tmp_select_signoff_task , true ) ); + ITKCALL(EPM_trigger_action(tmp_select_signoff_task,EPM_complete_action, "")); + } + + DOFREE( signoffs ); + //} + } + + + //DOFREE( values ); + DOFREE( processUser ); + DOFREE( arctic ); + DOFREE( tasks ); + printf("================== END =======================\n"); + + return ITK_ok; +} + +int JL_Auto_Order_Process(EPM_action_message_t msg){ + //֮̽ťbomܹ + int ifail = ITK_ok; + tag_t rootTask = NULLTAG,*attachments; + int attachments_num = 0; + char *object_type = NULL; + EPM_ask_root_task(msg.task, &rootTask); + //ȡĿ + EPM_ask_attachments(rootTask, EPM_target_attachment, &attachments_num, &attachments); + ::CoInitialize(NULL); //ʼOLE/COM⻷ + HRESULT hr = NULL; + _ConnectionPtr m_pConnection; // ݿ + _RecordsetPtr m_pRecordset; // + _CommandPtr m_pCommand; // ¼ + + char* server_address; + int valueNum=0; + PREF_ask_char_value("TC11_SqlServer_Link_ITK", valueNum, &server_address); + + hr = m_pConnection.CreateInstance(_uuidof(Connection));//Ӷʵ + if (SUCCEEDED(hr)) + { + m_pConnection->ConnectionString = (server_address); + //m_pConnection->ConnectionString = ("Provider = SQLOLEDB.1; Persist Security Info = False; User ID =infodba; Password=infodba; Initial Catalog = TCTEST2; Data Source = 10.110.81.13"); + //m_pConnection->ConnectionString = ("Provider = SQLOLEDB.1; Persist Security Info = False; User ID =lw; Password=lw590; Initial Catalog = HZPC; Data Source = 192.168.200.6"); + //printf("\n==========================================================\n"); + hr = m_pConnection->Open("", "", "", adConnectUnspecified);//ݿ + if (FAILED(hr)) + { + printf("Open Failed!"); + return 1; + } + else + { + for (int i = 0; i < attachments_num; i++) + { + char *uid_value; + AOM_ask_value_string(attachments[i], "object_type", &object_type); + printf("Ϊ%s\n",object_type); + if(strstr(object_type,"OrderRevision") == NULL || strstr(object_type,"Master") != NULL){ + continue; + } + ITK__convert_tag_to_uid(attachments[i],&uid_value); + printf("UIDΪ%s\n",uid_value); + char* updateSql = (char*)calloc(1024, sizeof(char)); + sprintf(updateSql,"update GD_CONTROLSTYPE_TABLE set ENABLED = 'true' where ORDER_TAGU = '%s'and CONTROL_NAME = 'btnbom_4'; update GD_CONTROLSTYPE_TABLE set BACKGROUND = 'GREEN' where ORDER_TAGU = '%s'and CONTROL_NAME = 'label_36'; ",uid_value,uid_value); + printf("дΪ%s\n",updateSql); + m_pConnection->Execute(_bstr_t(updateSql), 0, adCmdText); + updateSql = NULL; + + DOFREE(uid_value); + + //if(strstr(release_value,"Gd6_D") !=NULL && strstr(revision,"D00") == NULL){ + // //װŲϵͳݿд뷢š汾ڡʱϢ + // //޸ݿ + + // printf("ʼд\n"); + // //ʼд + // AOM_ask_value_string(attachments[i],"object_name",&item_name); + // AOM_ask_value_string(attachments[i],"item_id",&item_id); + // date_t date = NULLDATE; + // char *date_string = NULL; + // AOM_ask_value_date(attachments[i],"date_released",&date); + // DATE_date_to_string(date,"%Y-%m-%d %H:%M",&date_string); + // printf("ʱΪ%s\n",date_string); + // //printf("%s\n",date.year); + // //printf("%s\n",date.month); + // //printf("%s\n",date.day); + // //printf("%s\n",date.hour); + // //printf("%s\n",date.minute); + // //printf("%s\n",date.second); + // char* insertSql = (char*)calloc(1024, sizeof(char)); + // //sprintf(insertSql,"insert into AAA(PARTNO,PARTNAME,VerNO,REL_date) values('%s','%s','%s','%s')",item_id,item_name,revision,date_string); + // sprintf(insertSql,"insert into PLM_GetPartVerNO(PARTNO,PARTNAME,VerNO,REL_date) values('%s','%s','%s','%s')",item_id,item_name,revision,date_string); + // printf("дΪ%s\n",insertSql); + // m_pConnection->Execute(_bstr_t(insertSql), 0, adCmdText); + // insertSql = NULL; + // DOFREE(release_name); + // DOFREE(date_string); + //} + } + + } + } + else + { + printf("Create instance of connection failed!"); + return 1; + } + DOFREE(server_address); + DOFREE(object_type); + return ifail; +} \ No newline at end of file diff --git a/CONNOR_ITK/JL_Target_Moveto_Annex.cpp b/CONNOR_ITK/JL_Target_Moveto_Annex.cpp new file mode 100644 index 0000000..b6afe6a --- /dev/null +++ b/CONNOR_ITK/JL_Target_Moveto_Annex.cpp @@ -0,0 +1,268 @@ +#include "epm_handler_common.h" +#include +#include +#include +#include +#include +#include +#include "ae/dataset.h" +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "libxl.h" + +#include +#include +#include +#include "sstream" + +#include +#include +#include +extern "C" int POM_AM__set_application_bypass(logical bypass); + +using namespace libxl; +using namespace std; + +#define DOFREE(obj) \ +{ \ + if(obj) \ + { \ + MEM_free(obj); \ + obj = NULL; \ + } \ +} + +TCHAR* charToTchar(char * szWord){ + //TCHAR tszWord[1024] = {0}; + //#ifdef UNICODE + //MultiByteToWideChar(CP_ACP, 0, szWord, -1, tszWord, 1024); + //#else + //strcpy(tszWord, szWord); + //#endif + //return tszWord; + + //char *CStr = "string to convert"; + + size_t len = strlen(szWord) + 1; + + size_t converted = 0; + + wchar_t *WStr; + + WStr=(wchar_t*)malloc(len*sizeof(wchar_t)); + + mbstowcs_s(&converted, WStr, len, szWord, _TRUNCATE); + return WStr; +} + + +string ws2s(const std::wstring& wstr) +{ + + if (wstr.empty() || wstr.length() == 0) return std::string(); + int size_needed = WideCharToMultiByte(CP_ACP, 0, &wstr[0], (int)wstr.size(), NULL, 0, NULL, NULL); + std::string strTo(size_needed, 0); + WideCharToMultiByte(CP_ACP, 0, &wstr[0], (int)wstr.size(), &strTo[0], size_needed, NULL, NULL); + return strTo; +} + + +int JL_Target_Moveto_Annex(EPM_action_message_t msg){ + int ifail = ITK_ok,count = 0,valueNum = 0; + tag_t root_task=NULLTAG,model_path = NULLTAG,ref_obj=NULLTAG; + tag_t *attachments=NULLTAG; + Book* book = nullptr; + time_t t = time(0); + tm* local = localtime(&t); + wstringstream excel_path; + char ** values = NULL; + + + //ȡ + ITKCALL(EPM_ask_root_task(msg.task,&root_task)); + char * rootname=NULL,excelName[26]= ""; + EPM_ask_name2(root_task,&rootname); //ԭ̵ + cout<setKey(L"Halil Kural", L"windows-2723210a07c4e90162b26966a8jcdboe"); + + //ģݼ· + + //AE_find_dataset2("model.xlsx",&model_path); + + + //ȡѡ + PREF_ask_char_values("JL_Target_Moveto_Annex", &valueNum, &values);//ѡ + ITK__convert_uid_to_tag(values[0],&model_path); + AE_reference_type_t ae_ref; + ITKCALL(AE_ask_dataset_named_ref2(model_path, "excel", &ae_ref, &ref_obj)); + excel_path << getenv("temp"); + excel_path << "\\excel";//· + excel_path << local->tm_year; + excel_path << local->tm_yday; + excel_path << local->tm_hour; + excel_path << local->tm_min; + excel_path << local->tm_sec; + excel_path << ".xlsx"; + cout<< ws2s(excel_path.str()).c_str()<load(L"F:/Siemens/Teamcenter11/portal/model.xlsx")){ + if(book->load(excel_path.str().c_str())){ + for(int i=0;igetSheet(0); + sheet->writeStr(i+1, 0, charToTchar(itemID)); + sheet->writeStr(i+1, 1, charToTchar(name)); + sheet->writeStr(i+1, 2, charToTchar(type)); + sheet->writeStr(i+1, 3, L""); + //sheet->writeStr(i+1, 3, itemID); + + //cout<readStr(i, 0))<readStr(i, 1))<readStr(i, 2))<readStr(i, 3))<save(charToTchar(out_path)); + book->release();//ͷŶ󣡣 + + POM_AM__set_application_bypass(true); + //½excelݼ + const char name[AE_datasettype_name_size_c + 1] = "MSExcelX"; + //cout << name << endl; + tag_t datasetType = NULLTAG, tool = NULLTAG; + tag_t newDatasetTag = NULLTAG; //ݼtag + tag_t relation = NULLTAG; + //cout<<"111"< +#include +#include +#include +#include +#include +#include + +#include +#import "C:\Program Files\Common Files\System\ado\msado15.dll" no_namespace rename("EOF","adoEOF")rename("BOF","adoBOF") + +#define DOFREE(obj) \ +{ \ + if(obj) \ + { \ + MEM_free(obj); \ + obj = NULL; \ + } \ +} + +int JL_Welding_Syetem(EPM_action_message_t msg){ + int ifail = ITK_ok; + //㲿ʱΪD״̬Ұ汾D00汾װŲϵͳݿд뷢š汾ڡʱϢ + tag_t rootTask = NULLTAG,*attachments,relation_type = NULLTAG; + int attachments_num = 0; + char *object_type = NULL,*revision = NULL,*status = NULL,*item_id = NULL,*item_name = NULL; + EPM_ask_root_task(msg.task, &rootTask); + //ȡĿ + EPM_ask_attachments(rootTask, EPM_target_attachment, &attachments_num, &attachments); + + ::CoInitialize(NULL); //ʼOLE/COM⻷ + HRESULT hr = NULL; + _ConnectionPtr m_pConnection; // ݿ + _RecordsetPtr m_pRecordset; // + _CommandPtr m_pCommand; // ¼ + + hr = m_pConnection.CreateInstance(_uuidof(Connection));//Ӷʵ + if (SUCCEEDED(hr)) + { + //m_pConnection->ConnectionString = ("Provider = SQLOLEDB.1; Persist Security Info = False; User ID =infodba; Password=infodba; Initial Catalog = TCTEST2; Data Source = 10.110.81.13"); + m_pConnection->ConnectionString = ("Provider = SQLOLEDB.1; Persist Security Info = False; User ID =lw; Password=lw590; Initial Catalog = HZPC; Data Source = 192.168.200.6"); + //printf("\n==========================================================\n"); + hr = m_pConnection->Open("", "", "", adConnectUnspecified);//ݿ + if (FAILED(hr)) + { + printf("Open Failed!"); + return 1; + } + else + { + for (int i = 0; i < attachments_num; i++) + { + int release_counts = 0; + tag_t *release_tag = NULLTAG; + char release_value[SS_MAXPATHLEN] = ""; + char *release_name = NULL; + AOM_ask_value_string(attachments[i], "object_type", &object_type); + printf("Ϊ%s\n",object_type); + if(strstr(object_type,"PartsRevision") == NULL || strstr(object_type,"Master") != NULL){ + continue; + } + //õеķ״̬ + ITKCALL(AOM_ask_value_tags(attachments[i],"release_status_list",&release_counts, &release_tag)); + printf("%d\n",release_counts); + for (int j = 0; j < release_counts; j++) + { + AOM_ask_value_string(release_tag[j], "object_name", &release_name); //ԭexcelݼobject_name + printf("%s\n",release_name); + strcat(release_value,release_name); + } + //AOM_ask_value_string(attachments[i],"release_status_list",&status); + AOM_ask_value_string(attachments[i],"item_revision_id",&revision); + //ΪD״̬Ұ汾D00汾 + printf("%s%s\n",release_value,revision); + if(strstr(release_value,"Gd6_D") !=NULL && strstr(revision,"D00") == NULL){ + //װŲϵͳݿд뷢š汾ڡʱϢ + //޸ݿ + + printf("ʼд\n"); + //ʼд + AOM_ask_value_string(attachments[i],"object_name",&item_name); + AOM_ask_value_string(attachments[i],"item_id",&item_id); + date_t date = NULLDATE; + char *date_string = NULL; + AOM_ask_value_date(attachments[i],"date_released",&date); + DATE_date_to_string(date,"%Y-%m-%d %H:%M",&date_string); + printf("ʱΪ%s\n",date_string); + //printf("%s\n",date.year); + //printf("%s\n",date.month); + //printf("%s\n",date.day); + //printf("%s\n",date.hour); + //printf("%s\n",date.minute); + //printf("%s\n",date.second); + char* insertSql = (char*)calloc(1024, sizeof(char)); + //sprintf(insertSql,"insert into AAA(PARTNO,PARTNAME,VerNO,REL_date) values('%s','%s','%s','%s')",item_id,item_name,revision,date_string); + sprintf(insertSql,"insert into PLM_GetPartVerNO(PARTNO,PARTNAME,VerNO,REL_date) values('%s','%s','%s','%s')",item_id,item_name,revision,date_string); + printf("дΪ%s\n",insertSql); + m_pConnection->Execute(_bstr_t(insertSql), 0, adCmdText); + insertSql = NULL; + DOFREE(release_name); + DOFREE(date_string); + } + } + + } + } + else + { + printf("Create instance of connection failed!"); + return 1; + } + + + DOFREE(object_type); + DOFREE(revision); + DOFREE(status); + DOFREE(item_id); + DOFREE(item_name); + return ifail; +} diff --git a/CONNOR_ITK/JL_form_save.cpp b/CONNOR_ITK/JL_form_save.cpp new file mode 100644 index 0000000..e95ec39 --- /dev/null +++ b/CONNOR_ITK/JL_form_save.cpp @@ -0,0 +1,155 @@ +#include "epm_handler_common.h" +#include +#include +#include +#include + +#include +#import "C:\Program Files\Common Files\System\ado\msado15.dll" no_namespace rename("EOF","adoEOF")rename("BOF","adoBOF") + + +#define DOFREE(obj) \ +{ \ + if(obj) \ + { \ + MEM_free(obj); \ + obj = NULL; \ + } \ +} + +//ַָ +void split_img2(char* src, const char* separator, char** dest, int* num) { + /* + src Դַ׵ַ(bufĵַ) + separator ָķַָ + dest ַ + num ַָĸ + */ + char* pNext; + int count = 0; + if (src == NULL || strlen(src) == 0) //ĵַΪջ򳤶Ϊ0ֱֹ + return; + if (separator == NULL || strlen(separator) == 0) //δֱַָָֹ + return; + pNext = (char*)strtok(src, separator); //ʹ(char *)ǿת(Ȼдеıвָ) + while (pNext != NULL) { + *dest++ = pNext; + ++count; + pNext = (char*)strtok(NULL, separator); //ʹ(char *)ǿת + } + *num = count; +} + +int JL_form_save(METHOD_message_t *msg, va_list args){ + //޸ıͬ޸ijBOM״̬ + printf("ʼжǷҪ޸ijBOM\n"); + + tag_t formTag = NULLTAG; + tag_t revTag = NULLTAG; + + char *item_id; + + //ȡԶ + tag_t prop_tag = va_arg(args, tag_t); + //ȡֵ + char * values = va_arg(args, char*); + + printf_s("޸ĵֵ:%s\n",values); + + ITKCALL(PROP_ask_owning_object(prop_tag, &formTag)); + printf_s("foem:%d\n",formTag); + ITKCALL(AOM_ask_value_tag(formTag,"item_revision",&revTag)); + printf_s("rev:%d\n",revTag); + ITKCALL(AOM_ask_value_string(revTag,"item_id",&item_id)); + printf_s("id:%s\n",item_id); + //޸ݿ + ::CoInitialize(NULL); //ʼOLE/COM⻷ + HRESULT hr = NULL; + _ConnectionPtr m_pConnection; // ݿ + _RecordsetPtr m_pRecordset; // + _CommandPtr m_pCommand; // ¼ + + char* server_address; + int valueNum=0; + PREF_ask_char_value("TC11_SqlServer_Link_ITK", valueNum, &server_address); + + hr = m_pConnection.CreateInstance(_uuidof(Connection));//Ӷʵ + if (SUCCEEDED(hr)) + { + /* + Provider=SQLOLEDB.1 ------ݿoledbķʽbai + Persist Security Info ----Ƿ񱣴氲ȫϢdu + User ID-------------------û + PassWord------------------zhi + Initial Catalog-----------ݿƻݿipĿdao¼ + Data Source---------------Դ + */ + m_pConnection->ConnectionString = (server_address); + //printf("\n==========================================================\n"); + hr = m_pConnection->Open("", "", "", adConnectUnspecified);//ݿ + if (FAILED(hr)) + { + printf("Open Failed!"); + return 1; + } + else + { + //char* updateLable = (char*)calloc(1024, sizeof(char)); + //sprintf(updateLable, "update GD_ORDERBOM_LABLE set Lable = '' where ItemID = '%s'", "50HS502"); + //m_pConnection->Execute(_bstr_t(updateLable), 0, adCmdText); + //updateLable = NULL; + //printf("³ɹ"); + char * sjzl = ""; + char * mz = ""; + char * wlfl = ""; + char * dw = ""; + char * jcjwlh = ""; + char * sfqdj = ""; + char * gyzy = ""; + AOM_ask_value_string(formTag, "gd6_sjzl", &sjzl); + AOM_ask_value_string(formTag, "gd6_mz", &mz); + AOM_ask_value_string(formTag, "gd6_wlfl", &wlfl); + AOM_ask_value_string(formTag, "gd6_dw", &dw); + AOM_ask_value_string(formTag, "gd6_jcjwlh", &jcjwlh); + AOM_ask_value_string(formTag, "gd6_sfqdj", &sfqdj); + AOM_ask_value_string(formTag, "gd6_gyzy", &gyzy); + + char* updateSql = (char*)calloc(1024, sizeof(char)); + sprintf(updateSql, "UPDATE GD_ORDERBOM_DATA SET sjzl = '%s',mz = '%s',wlfl='%s',dw='%s',jcjwlh='%s',sfqdj='%s',gyzy='%s' where id = '%s'",sjzl,mz,wlfl,dw,jcjwlh,sfqdj,gyzy,item_id); + printf("%s",updateSql); + m_pConnection->Execute(_bstr_t(updateSql), 0, adCmdText); + + DOFREE(sjzl); + DOFREE(mz); + DOFREE(wlfl); + DOFREE(dw); + DOFREE(jcjwlh); + DOFREE(sfqdj); + DOFREE(gyzy); + //sjzl = NULL; + //mz = NULL; + //wlfl = NULL; + //dw = NULL; + //jcjwlh = NULL; + //sfqdj = NULL; + //gyzy = NULL; + updateSql = NULL; + } + } + else + { + printf("Create instance of connection failed!"); + return 1; + } + DOFREE(server_address); + DOFREE(item_id); + + //int self_num = 0; + //char* revbuf_test[8] = { }; //ŷַָ + //split_img2(object_name,"/", revbuf_test, &self_num); + //char self_new_name[WSO_name_size_c + 1] = ""; + //strcat(self_new_name,revbuf_test[0]); + //printf("idΪ%s",self_new_name); + printf("=========================޸ijBOM END ===================\n"); + return 0; +} \ No newline at end of file diff --git a/CONNOR_ITK/common_itk_util.c b/CONNOR_ITK/common_itk_util.c new file mode 100644 index 0000000..0d17a01 --- /dev/null +++ b/CONNOR_ITK/common_itk_util.c @@ -0,0 +1,288 @@ +/** +* @file common_itk_util.cpp +* @brief itk warpper utility function +* @author James +* @history +* =================================================================================== +* Date Name Description of Change +* 18-July-2008 James +*/ + +#pragma warning (disable: 4996) +#pragma warning (disable: 4819) + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +//#include +//#include +//#include +//#include + +#include +//#include +#include +#include +//#include +//#include +#include "common_itk_util.h" + +#ifdef WIN32 +#include +#include +#else +#include +#endif + + +#define ARGS_LENGTH 200 +#define ARGS_NAME_DEBUG "-debug" +#define DEBUG "-debug=" +#define MAX_PRINTLINE_LENGTH 2000 +#define MAX_PATH_LENGTH 2000 +#define MAX_ARGUMENT_LENGTH 400 +#define MAX_PARAMNAME_LENGTH 50 +#define MAX_FILE_EXT_LENGTH 10 +#define TRUE_FLAG 1 +#define FALSE_FLAG 0 +#define DETAILLOG 1 + + +void ECHO(char *format, ...) +{ + //if( !YFJC_OPT_DEBUG ) + // return; + + char msg[4000]; + va_list args; + + va_start( args, format ); + vsprintf( msg, format, args ); + va_end( args ); + + printf( msg ); + TC_write_syslog( msg ); +} + +FILE* logFile = NULL; + +void set_bypass(logical bypass) +{ + AM__set_application_bypass(bypass); +} +/*=============================================================================* + * FUNCTION: current_time + * PURPOSE : get the current datetime + * INPUT: + * date_t* date_tag // current date time tag + * + * RETURN: + * void + *============================================================================*/ +void current_time( date_t * date_tag ) +{ + time_t ltime; + struct tm *today ; + + // Set time zone from TZ environment variable. If TZ is not set, + // the operating system is queried to obtain the default value + // for the variable. + // + //_tzset(); + + // Get UNIX-style time and display as number and string. + time( <ime ); + + today = localtime( <ime ); + date_tag->year = today->tm_year + 1900 ; + date_tag->month = today->tm_mon ; + date_tag->day = today->tm_mday ; + date_tag->hour = today->tm_hour ; + date_tag->minute = today->tm_min ; + date_tag->second = today->tm_sec ; +} +/*=============================================================================* + * FUNCTION: CreateLogFile + * PURPOSE : create log file + * INPUT: + * char* FunctionName // the funtion which need to create log file + * FILE** logFile // out: the log file pointer + * + * RETURN: + * void + *============================================================================*/ +void CreateLogFile(char* FunctionName, char **fullname) +{ + int i=0, ifail = ITK_ok; + //date_t status_now; + //char* date_string = NULL; + char date_string[MAX_PATH_LENGTH]; + char logFileDir[MAX_PATH_LENGTH]; + char logFileName[MAX_PATH_LENGTH]; + + char* session_uid = NULL; + tag_t session_tag = NULLTAG; + time_t now; + struct tm *p; + + time(&now); + + logFile = NULL; + //current_time(&status_now); + p=localtime(&now); + + memset(date_string, 0, sizeof(date_string)); + sprintf(date_string,"%4d%02d%02d%02d%02d%02d",1900+p->tm_year,p->tm_mon+1 ,p->tm_mday ,p->tm_hour,p->tm_min ,p->tm_sec ); + //if( DATE_date_to_string( status_now, "%Y%m%d%H%M%S", &date_string) != ITK_ok ) + //ifail = ITK_date_to_string (status_now, &date_string ); + //if (ifail) + //{ + // printf("!*ERROR*!: Failed to get current date time\n"); + // goto CLEANUP; + //} + + memset(logFileDir, 0, sizeof(logFileDir)); + memset(logFileName, 0, sizeof(logFileName)); + //get log dir + sprintf(logFileDir, "%s", getenv("TEMP")); + printf("\n log file dir: %s\n", logFileDir); + //try to change dir to TC_USER_LOG_DIR + if(chdir(logFileDir)!=ITK_ok) + { + //not set TC_USER_LOG_DIR + //log in to default TC_LOG + memset(logFileDir, 0, sizeof(logFileDir)); + sprintf(logFileDir, "%s", getenv("TC_LOG")); + printf("\n TC_USER_LOG_DIR invalide, log file dir: %s\n", logFileDir); + if(chdir(logFileDir)!=ITK_ok) + { + //still can not change to log dir + printf("!*ERROR*!: Failed to change dir to TC_USER_LOG_DIR\n"); + goto CLEANUP; + } + } + + //get session_uid to make sure the log file name unique + POM_ask_session(&session_tag); + ITK__convert_tag_to_uid(session_tag, &session_uid); + + + //get logFileName + sprintf(logFileName, "%s_%s_%s.log", FunctionName, session_uid, date_string); + printf("log file name: %s\n", logFileName); + + *fullname = (char *)MEM_alloc(sizeof(char)*512); + sprintf(*fullname,"%s\\%s",logFileDir,logFileName); + + //for(i = 0; _access((char *)logFileName, 4) == 0; i++) + /*{ + memset(logFileName, 0, sizeof(logFileName)); + sprintf(logFileName, "%s_%s_%s_%d.log", FunctionName, session_uid, date_string, i); + } + printf("final log file name: %s\n", logFileName);*/ + + //create log file + logFile = fopen(logFileName, "w"); + +CLEANUP: + //DOFREE(date_string); + DOFREE(session_uid); +} + + +/*=============================================================================* + * FUNCTION: WriteLog + * PURPOSE : write log, if debug log File not null, write log message to log File + * INPUT: + * const char* format // debug message string + * + * RETURN: + * void + *============================================================================*/ +void WriteLog(const char* format, ...) +{ + va_list arg; + char tmp[MAX_PRINTLINE_LENGTH]; + + if(logFile) + { + //get the message + memset(tmp, 0, sizeof(tmp)); + va_start(arg, format); + vsprintf(tmp, format, arg); + va_end(arg); + + //----------print to command window for trace--------// + printf("%s\n", tmp); + + //print message to log file + fprintf(logFile, "%s\n", tmp); + fflush(logFile); + } + else + { + printf("*!Error!*: Log File Not Exist\n"); + } +} + +void CloseLog(void) +{ + if(logFile) + { + fclose(logFile); + logFile = NULL; + } +} + +//void getTypeinfo(char *type) +//{ +// int ulen = 0,i=0,tempcount=0,asd=0; +// +// char temp[128]=""; +// ulen = strlen(type); +// asd = ulen-1; +// for(i=0;i < ulen;i++) +// { +// if(type[i] == ';') +// { +// temp[tempcount] = '\0'; +// strcpy(excludetypes[typecount].type,temp); +// strcpy(temp,""); +// tempcount = 0; +// typecount = typecount + 1; +// } +// else +// { +// +// temp[tempcount] = type[i]; +// tempcount = tempcount + 1; +// if(i==asd) +// { +// temp[tempcount] = '\0'; +// strcpy(excludetypes[typecount].type,temp); +// typecount = typecount + 1; +// } +// +// } +// +// } +//} \ No newline at end of file diff --git a/CONNOR_ITK/common_itk_util.h b/CONNOR_ITK/common_itk_util.h new file mode 100644 index 0000000..640e412 --- /dev/null +++ b/CONNOR_ITK/common_itk_util.h @@ -0,0 +1,39 @@ +/** +* @file common_itk_util.h +* @brief itk warpper utility function +* @author James +* @history +* =================================================================================== +* Date Name Description of Change +* 09-July-2008 James +*/ + +#ifndef COMMON_ITK_UTIL +#define COMMON_ITK_UTIL + +#ifdef __cplusplus +extern "C" { +#endif + +#define DOFREE(obj) \ +{ \ + if(obj) \ + { \ + MEM_free(obj); \ + obj = NULL; \ + } \ +} +void ECHO(char *format, ...); +void CreateLogFile(char* FunctionName, char **fullname); +void WriteLog(const char* format, ...); +void CloseLog(void); +//int FindDatasetReferenceExt( tag_t datasettype, const char *datasettype_ref, char ext[10] ); +//int CompareDate( date_t date1, date_t date2 ); +//int GetRandomTempFile( char tempFile[256] ); +//logical IsItemRevisionType( char object_type[WSO_name_size_c + 1] ); + +#ifdef __cplusplus +} +#endif + +#endif \ No newline at end of file diff --git a/CONNOR_ITK/connor_custom_main.cxx b/CONNOR_ITK/connor_custom_main.cxx new file mode 100644 index 0000000..5ced450 --- /dev/null +++ b/CONNOR_ITK/connor_custom_main.cxx @@ -0,0 +1,44 @@ + + +#pragma warning (disable: 4819) + +#include +#include +#include "epm_register_handler.h" +#include "epm_handler_common.h" + + +#ifdef __cplusplus +extern "C" { +#endif + + + + DLLAPI int jl_register_callbacks() + { + printf("=======================================\n"); + int ifail = ITK_ok; + ifail = CUSTOM_register_exit( + "jl", + "USERSERVICE_register_methods", + (CUSTOM_EXIT_ftn_t)USERSERVICE_custom_register_methods); + + + ifail = CUSTOM_register_exit( + "jl", + "USER_gs_shell_init_module", + (CUSTOM_EXIT_ftn_t)CUST_init_module); + + return ifail; + } + +#ifdef __cplusplus +} +#endif + + + + +/** +* @} +*/ \ No newline at end of file diff --git a/CONNOR_ITK/epm_handler_common.h b/CONNOR_ITK/epm_handler_common.h new file mode 100644 index 0000000..cd28693 --- /dev/null +++ b/CONNOR_ITK/epm_handler_common.h @@ -0,0 +1,60 @@ + + + +#ifndef EPM_HANDLER_COMMON +#define EPM_HANDLER_COMMON + +#include +#include + +#include +#include + + +#ifdef __cplusplus +extern "C" { +#endif + + + void split(char *src, const char *separator, char **dest, int *num); + + int JLCS_05_BOMSendOutSap(EPM_action_message_t msg); + int JLCS_05_BOMSendOutSap_Single(EPM_action_message_t msg); + int JLCS_05_BOMUpdateSap_MasterData(EPM_action_message_t msg); + int JLCS_05_BOMSendOutSap_MasterData(EPM_action_message_t msg); + int JLCS_05_BOMDeleteSap_MasterData(EPM_action_message_t msg); + int JL_Send_Mail(EPM_action_message_t msg); + int Connor_set_bypass(void *returnValue); + int ORIGIN_close_bypass(void *returnValue); + int Create_Remodel_Process(void *returnValue); + int Send_Order_Process(void *returnValue); + int DMU_Review_Process(void *returnValue); + int JL_Change_Inspection_Of_Basic_Part(EPM_rule_message_t msg); + int jl_insert_img_pdf(EPM_action_message_t msg); + int jl_insert_modular(EPM_action_message_t msg); + int jl_dmu_auto(EPM_action_message_t msg); + int jl_locomotion_item(EPM_action_message_t msg); + int JL_sign_tongzhi(EPM_action_message_t msg); + int JL_sign_master(EPM_action_message_t msg); + int ORIGIN_ask_sign_info(tag_t task_node, char *output_str,char *task_name,char *arg3value); + int JL_Judge_Revision (EPM_action_message_t msg); + int JL_add_to_referenece(EPM_action_message_t msg); + int JL_create_process(EPM_action_message_t msg); + int test (EPM_action_message_t msg); + int Super_Bom_Appent_Data (void *returnValue); + int JL_Target_Moveto_Annex(EPM_action_message_t msg); + int JL_Add_FinishTime(EPM_action_message_t msg); + int JL_form_save(METHOD_message_t *msg, va_list args); + int JL_Welding_Syetem(EPM_action_message_t msg); + int JL_Auto_Order_Process(EPM_action_message_t msg); + //user service end +#ifdef __cplusplus +} +#endif + +#endif + + +/** +* @} +*/ \ No newline at end of file diff --git a/CONNOR_ITK/epm_register_handler.cxx b/CONNOR_ITK/epm_register_handler.cxx new file mode 100644 index 0000000..590805e --- /dev/null +++ b/CONNOR_ITK/epm_register_handler.cxx @@ -0,0 +1,499 @@ + +#include +#include + + +#include +#include +#include +#include +#include +#include +/** +* @headerfile user's header files +*/ +#include "epm_register_handler.h" +#include "epm_handler_common.h" + +using namespace std; + +// Method and Workflow Handler +extern DLLAPI int CUST_init_module(int *decision, va_list args) +{ + int ifail = ITK_ok; + + //Ŀµԣid,ƣϷ࣬""дexcelŵ + ifail = EPM_register_action_handler("JL_Target_Moveto_Annex", "JL_Target_Moveto_Annex", + (EPM_action_handler_t)JL_Target_Moveto_Annex); + if (ifail) + { + printf("register JL_Target_Moveto_Annex failed\n"); + } + else + { + printf("register JL_Target_Moveto_Annex successfully\n"); + } + + //㲿ʱΪD״̬Ұ汾D00汾װŲϵͳݿд뷢š汾ڡʱϢ + ifail = EPM_register_action_handler("JL_Welding_Syetem", "JL_Welding_Syetem", + (EPM_action_handler_t)JL_Welding_Syetem); + if (ifail) + { + printf("register JL_Welding_Syetem failed\n"); + } + else + { + printf("register JL_Welding_Syetem successfully\n"); + } + + //֮̽ťbom'ܹ + ifail = EPM_register_action_handler("JL_Auto_Order_Process", "JL_Auto_Order_Process", + (EPM_action_handler_t)JL_Auto_Order_Process); + if (ifail) + { + printf("register JL_Auto_Order_Process failed\n"); + } + else + { + printf("register JL_Auto_Order_Process successfully\n"); + } + + //һڵʱ䵽 + ifail = EPM_register_action_handler("JL_Add_FinishTime", "JL_Add_FinishTime", + (EPM_action_handler_t)JL_Add_FinishTime); + if (ifail) + { + printf("register JL_Add_FinishTime failed\n"); + } + else + { + printf("register JL_Add_FinishTime successfully\n"); + } + + // + ifail = EPM_register_action_handler("JL_Change_Inspection_Of_Basic_Part", "JL_Change_Inspection_Of_Basic_Part", + (EPM_action_handler_t)JL_Change_Inspection_Of_Basic_Part); + if (ifail) + { + printf("register JL_Change_Inspection_Of_Basic_Part failed\n"); + } + else + { + printf("register JL_Change_Inspection_Of_Basic_Part successfully\n"); + } + //Ϣʼ֪ͨ + ifail = EPM_register_action_handler("JL_Send_Mail", "JL_Send_Mail", + (EPM_action_handler_t)JL_Send_Mail); + + if (ifail) + { + printf("register JL_Send_Mail failed\n"); + } + else + { + printf("register JL_Send_Mail successfully\n"); + } + //ϴBOMSAP + ifail = EPM_register_action_handler("JLCS_05_BOMSendOutSap", "JLCS_05_BOMSendOutSap", + (EPM_action_handler_t)JLCS_05_BOMSendOutSap); + + if(ifail) + { + printf("register JLCS_05_BOMSendOutSap failed\n"); + }else + { + printf("register JLCS_05_BOMSendOutSap successfully\n"); + } + + //ϴBOMSAPҪУ·һӼ + ifail = EPM_register_action_handler("JLCS_05_BOMSendOutSap_Single", "JLCS_05_BOMSendOutSap_Single", + (EPM_action_handler_t)JLCS_05_BOMSendOutSap_Single); + + if(ifail) + { + printf("register JLCS_05_BOMSendOutSap_Single failed\n"); + }else + { + printf("register JLCS_05_BOMSendOutSap_Single successfully\n"); + } + + //SAP + ifail = EPM_register_action_handler("JLCS_05_BOMUpdateSap_MasterData", "JLCS_05_BOMUpdateSap_MasterData", + (EPM_action_handler_t)JLCS_05_BOMUpdateSap_MasterData); + if(ifail) + { + printf("register JLCS_05_BOMUpdateSap_MasterData failed\n"); + }else + { + printf("register JLCS_05_BOMUpdateSap_MasterData successfully\n"); + } + + //ɾSAP + ifail = EPM_register_action_handler("JLCS_05_BOMDeleteSap_MasterData", "JLCS_05_BOMDeleteSap_MasterData", + (EPM_action_handler_t)JLCS_05_BOMDeleteSap_MasterData); + + if(ifail) + { + printf("register JLCS_05_BOMDeleteSap_MasterData failed\n"); + }else + { + printf("register JLCS_05_BOMDeleteSap_MasterData successfully\n"); + } + //ϴݵSAP + ifail = EPM_register_action_handler("JLCS_05_BOMSendOutSap_MasterData", "JLCS_05_BOMSendOutSap_MasterData", + (EPM_action_handler_t)JLCS_05_BOMSendOutSap_MasterData); + + if (ifail) + { + printf("register JLCS_05_BOMSendOutSap_MasterData failed\n"); + } + else + { + printf("register JLCS_05_BOMSendOutSap_MasterData successfully\n"); + } + + + + //PDFͼƬ + ifail = EPM_register_action_handler("JL_insert_img_pdf", "JL_insert_img_pdf", + (EPM_action_handler_t)jl_insert_img_pdf); + if (ifail == ITK_ok) + { + fprintf(stdout, "Registering action handler tm_insert_img_pdf completed!\n"); + } + else + { + fprintf(stdout, "Registering action handler tm_insert_img_pdf failed %d!\n", ifail); + } + + //ʷ + ifail = EPM_register_action_handler("JL_insert_modular", "JL_insert_modular", + (EPM_action_handler_t)jl_insert_modular); + if (ifail == ITK_ok) + { + fprintf(stdout, "Registering action handler JL_insert_modular completed!\n"); + } + else + { + fprintf(stdout, "Registering action handler JL_insert_modular failed %d!\n", ifail); + } + + //DMU֤ + ifail = EPM_register_action_handler("jl_dmu_auto", "jl_dmu_auto", + (EPM_action_handler_t)jl_dmu_auto); + if (ifail == ITK_ok) + { + fprintf(stdout, "Registering action handler jl_dmu_auto completed!\n"); + } + else + { + fprintf(stdout, "Registering action handler jl_dmu_auto failed %d!\n", ifail); + } + + //Ƶָϵļ + ifail = EPM_register_action_handler("jl_locomotion_item", "jl_locomotion_item", + (EPM_action_handler_t)jl_locomotion_item); + if (ifail == ITK_ok) + { + fprintf(stdout, "Registering action handler jl_locomotion_item completed!\n"); + } + else + { + fprintf(stdout, "Registering action handler jl_locomotion_item failed %d!\n", ifail); + } + + //֪ͨڵǩ + ifail = EPM_register_action_handler("JL_sign_tongzhi", "JL_sign_tongzhi", + (EPM_action_handler_t)JL_sign_tongzhi); + if (ifail == ITK_ok) + { + fprintf(stdout, "Registering action handler JL_sign_tongzhi completed!\n"); + } + else + { + fprintf(stdout, "Registering action handler JL_sign_tongzhi failed %d!\n", ifail); + } + + //ڵǩ + ifail = EPM_register_action_handler("JL_sign_master", "JL_sign_master", + (EPM_action_handler_t)JL_sign_master); + if (ifail == ITK_ok) + { + fprintf(stdout, "Registering action handler JL_sign_master completed!\n"); + } + else + { + fprintf(stdout, "Registering action handler JL_sign_master failed %d!\n", ifail); + } + //ж϶汾Ƿõİ汾 + ifail = EPM_register_action_handler("JL_Judge_Revision", "JL_Judge_Revision", + (EPM_action_handler_t)JL_Judge_Revision); + if (ifail == ITK_ok) + { + fprintf(stdout, "Registering action handler JL_Judge_Revision completed!\n"); + } + else + { + fprintf(stdout, "Registering action handler JL_Judge_Revision failed %d!\n", ifail); + } + //µļƵĿ + ifail = EPM_register_action_handler("JL_add_to_referenece", "JL_add_to_referenece", + (EPM_action_handler_t)JL_add_to_referenece); + if (ifail == ITK_ok) + { + fprintf(stdout, "Registering action handler JL_add_to_referenece completed!\n"); + } + else + { + fprintf(stdout, "Registering action handler JL_add_to_referenece failed %d!\n", ifail); + } + //SAPά + ifail = EPM_register_action_handler("JL_create_process", "JL_create_process", + (EPM_action_handler_t)JL_create_process); + if (ifail == ITK_ok) + { + fprintf(stdout, "Registering action handler JL_create_process completed!\n"); + } + else + { + fprintf(stdout, "Registering action handler JL_create_process failed %d!\n", ifail); + } + // + ifail = EPM_register_action_handler("test", "test", + (EPM_action_handler_t)test); + if (ifail == ITK_ok) + { + fprintf(stdout, "Registering action handler test completed!\n"); + } + else + { + fprintf(stdout, "Registering action handler test failed %d!\n", ifail); + } + + + + return ifail; +} +// +////register service method +extern DLLAPI int USERSERVICE_custom_register_methods() +{ + int + status = ITK_ok, + numberOfArguments = 0, + returnValueType = USERARG_STRING_TYPE, + *argumentList = NULL; + USER_function_t functionPtr; + + //METHOD_id_t mth_tag; + + ////METHOD_find_method("Gd6_PartsRevisionMaster",TC_import_msg,&mth_tag); + + // + //vector typeVec; + //typeVec.push_back("gd6_sjzl"); + //typeVec.push_back("gd6_mz"); + //typeVec.push_back("gd6_wlfl"); + //typeVec.push_back("gd6_dw"); + //typeVec.push_back("gd6_jcjwlh"); + //typeVec.push_back("gd6_sfqdj"); + //typeVec.push_back("gd6_gyzy"); + + //for (int i = 0; i < typeVec.size(); i++) { + // METHOD_find_prop_method("Gd6_PartsRevisionMaster", typeVec[i].c_str(), PROP_set_value_string_msg, &mth_tag); + // if ( mth_tag.id != NULLTAG ) + // { + // printf("update superBOM start \n "); + // ITKCALL(status = METHOD_add_action2( mth_tag, METHOD_post_action_type,( METHOD_function_t ) JL_form_save, NULL ,true) ); + // if(status == ITK_ok){ + // printf("success superBOM \n "); + // }else{ + // printf("faild superBOM \n "); + // } + // }else{ + // printf("not find Gd6_PartsRevisionMaster \n "); + // } + //} + + + + + //QTM_ebom_to_pbom + //涨javaҪݹĸ + numberOfArguments = 1; + //Ҫõĺַַ + functionPtr = Connor_set_bypass; + //javaҪݵIJ + argumentList = (int*)MEM_alloc(numberOfArguments * sizeof(int)); + argumentList[0] = USERARG_STRING_TYPE; + //argumentList[1] = USERARG_DATE_TYPE; + //argumentList[2] = USERARG_STRING_TYPE +USERARG_ARRAY_TYPE; + //argumentList[1] = USERARG_STRING_TYPE + USERARG_ARRAY_TYPE; + //returnValueType = USERARG_STRING_TYPE; + //巵ֵ + returnValueType = USERARG_VOID_TYPE; + status = USERSERVICE_register_method("Connor_set_bypass", functionPtr, numberOfArguments, + argumentList, returnValueType); + MEM_free(argumentList); + if (status == ITK_ok) + { + fprintf(stdout, "\n Registering Connor_set_bypass finished\n"); + } + else + { + fprintf(stdout, "\n Registering Connor_set_bypass failed %d\n", status); + } + + + //=========================================== + + numberOfArguments = 1; + functionPtr = ORIGIN_close_bypass; + argumentList = (int*)MEM_alloc(numberOfArguments * sizeof(int)); + argumentList[0] = USERARG_STRING_TYPE; + //argumentList[1] = USERARG_STRING_TYPE + USERARG_ARRAY_TYPE; + //returnValueType = USERARG_STRING_TYPE; + returnValueType = USERARG_VOID_TYPE; + status = USERSERVICE_register_method("ORIGIN_close_bypass", functionPtr, numberOfArguments, + argumentList, returnValueType); + MEM_free(argumentList); + if (status == ITK_ok) + { + fprintf(stdout, "\n Registering ORIGIN_close_bypass finished\n"); + } + else + { + fprintf(stdout, "\n Registering ORIGIN_close_bypass failed %d\n", status); + } + + + //=========================================== + + //涨javaҪݹĸ + numberOfArguments = 3; + //Ҫõĺַַ + functionPtr = DMU_Review_Process; + //javaҪݵIJ + argumentList = (int*)MEM_alloc(numberOfArguments * sizeof(int)); + argumentList[0] = USERARG_TAG_TYPE; + argumentList[1] = USERARG_STRING_TYPE; + argumentList[2] = USERARG_STRING_TYPE; + //argumentList[1] = USERARG_TAG_TYPE; + //argumentList[1] = USERARG_DATE_TYPE; + //argumentList[2] = USERARG_STRING_TYPE +USERARG_ARRAY_TYPE; + //argumentList[1] = USERARG_STRING_TYPE + USERARG_ARRAY_TYPE; + //returnValueType = USERARG_STRING_TYPE; + //巵ֵ + returnValueType = USERARG_VOID_TYPE; + //ITKCALL(); + status = USERSERVICE_register_method("DMU_Review_Process", functionPtr, numberOfArguments, + argumentList, returnValueType); + MEM_free(argumentList); + if (status == ITK_ok) + { + fprintf(stdout, "\n Registering DMU_Review_Process finished\n"); + } + else + { + fprintf(stdout, "\n Registering DMU_Review_Process failed %d\n", status); + } + + + //=========================================== + + //涨javaҪݹĸ + numberOfArguments = 3; + //Ҫõĺַַ + functionPtr = Send_Order_Process; + //javaҪݵIJ + argumentList = (int*)MEM_alloc(numberOfArguments * sizeof(int)); + argumentList[0] = USERARG_TAG_TYPE; + argumentList[1] = USERARG_STRING_TYPE; + argumentList[2] = USERARG_STRING_TYPE; + //argumentList[1] = USERARG_TAG_TYPE; + //argumentList[1] = USERARG_DATE_TYPE; + //argumentList[2] = USERARG_STRING_TYPE +USERARG_ARRAY_TYPE; + //argumentList[1] = USERARG_STRING_TYPE + USERARG_ARRAY_TYPE; + //returnValueType = USERARG_STRING_TYPE; + //巵ֵ + returnValueType = USERARG_VOID_TYPE; + //ITKCALL(); + status = USERSERVICE_register_method("Send_Order_Process", functionPtr, numberOfArguments, + argumentList, returnValueType); + MEM_free(argumentList); + if (status == ITK_ok) + { + fprintf(stdout, "\n Registering Send_Order_Process finished\n"); + } + else + { + fprintf(stdout, "\n Registering Send_Order_Process failed %d\n", status); + } + + //=========================================== + + //涨javaҪݹĸ + numberOfArguments = 3; + //Ҫõĺַַ + functionPtr = Create_Remodel_Process; + //javaҪݵIJ + argumentList = (int*)MEM_alloc(numberOfArguments * sizeof(int)); + argumentList[0] = USERARG_TAG_TYPE; + argumentList[1] = USERARG_STRING_TYPE; + argumentList[2] = USERARG_STRING_TYPE; + //argumentList[1] = USERARG_TAG_TYPE; + //argumentList[1] = USERARG_DATE_TYPE; + //argumentList[2] = USERARG_STRING_TYPE +USERARG_ARRAY_TYPE; + //argumentList[1] = USERARG_STRING_TYPE + USERARG_ARRAY_TYPE; + //returnValueType = USERARG_STRING_TYPE; + //巵ֵ + returnValueType = USERARG_VOID_TYPE; + //ITKCALL(); + status = USERSERVICE_register_method("Create_Remodel_Process", functionPtr, numberOfArguments, + argumentList, returnValueType); + MEM_free(argumentList); + if (status == ITK_ok) + { + fprintf(stdout, "\n Registering Create_Remodel_Process finished\n"); + } + else + { + fprintf(stdout, "\n Registering Create_Remodel_Process failed %d\n", status); + } + + + //=========================================== + + //涨javaҪݹĸ + numberOfArguments = 1; + //Ҫõĺַַ + functionPtr = Super_Bom_Appent_Data; + //javaҪݵIJ + argumentList = (int*)MEM_alloc(numberOfArguments * sizeof(int)); + argumentList[0] = USERARG_TAG_TYPE; + //argumentList[1] = USERARG_TAG_TYPE; + //argumentList[1] = USERARG_DATE_TYPE; + //argumentList[2] = USERARG_STRING_TYPE +USERARG_ARRAY_TYPE; + //argumentList[1] = USERARG_STRING_TYPE + USERARG_ARRAY_TYPE; + //returnValueType = USERARG_STRING_TYPE; + //巵ֵ + returnValueType = USERARG_VOID_TYPE; + //ITKCALL(); + status = USERSERVICE_register_method("Super_Bom_Appent_Data", functionPtr, numberOfArguments, + argumentList, returnValueType); + MEM_free(argumentList); + if (status == ITK_ok) + { + fprintf(stdout, "\n Registering Super_Bom_Appent_Data finished\n"); + } + else + { + fprintf(stdout, "\n Registering Super_Bom_Appent_Data failed %d\n", status); + } + + + //=========================================== + + return(status); +} + diff --git a/CONNOR_ITK/epm_register_handler.h b/CONNOR_ITK/epm_register_handler.h new file mode 100644 index 0000000..264ce72 --- /dev/null +++ b/CONNOR_ITK/epm_register_handler.h @@ -0,0 +1,21 @@ + + +#ifndef EPM_REGISTER_HANDLER_CUSTOM +#define EPM_REGISTER_HANDLER_CUSTOM + +#include + +#ifdef __cplusplus +extern "C" { +#endif + + extern DLLAPI int CUST_init_module(int *, va_list); + extern DLLAPI int USERSERVICE_custom_register_methods(); + + +#ifdef __cplusplus +} +#endif + +#endif + diff --git a/CONNOR_ITK/jl_dmu_auto.cxx b/CONNOR_ITK/jl_dmu_auto.cxx new file mode 100644 index 0000000..087ba86 --- /dev/null +++ b/CONNOR_ITK/jl_dmu_auto.cxx @@ -0,0 +1,281 @@ +#include +#import "C:\Program Files\Common Files\System\ado\msado15.dll" no_namespace rename("EOF","adoEOF")rename("BOF","adoBOF") +#include +#include "epm_handler_common.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "ocilib.h" +#include +#include +#pragma warning(disable : 4996) +#include +#define DOFREE(obj) \ +{ \ + if(obj) \ + { \ + MEM_free(obj); \ + obj = NULL; \ + } \ +} + +using namespace std; +//#include "E:/20200520/DM_ITK/jf_itk/jf_itk/jf_itk/ocilib.cxx" + +int jl_dmu_auto(EPM_action_message_t msg) { + ::CoInitialize(NULL); //ʼOLE/COM⻷ + HRESULT hr = NULL; + _ConnectionPtr m_pConnection; // ݿ + _RecordsetPtr m_pRecordset; // + _CommandPtr m_pCommand; // ¼ + + int ifail = ITK_ok, count = 0, arg_cnt = 0, item_mast_rev_count = 0,valueNum=0; + int outputColumn = 0, outputValueCount = 0; + tag_t root_task = NULL_TAG; + tag_t* attachments = NULL, * item_mast_rev = NULLTAG; + //char arg1value[1024] = ""; + //char* arg = NULL, * argflag = NULL, * argvalue = NULL; + char* item_id = NULL, *type_class=NULL,*part_type = NULL; + char* object_type = NULL; + //char* control_name = "btnDmu"; //DMU֤ͨťname + char* puid = NULL; + //char*** outputValue = (char***)calloc(1024, sizeof(char**)); + char* describeSelect = (char*)calloc(1024, sizeof(char)); + char* describeUpdate = (char*)calloc(1024, sizeof(char)); + //label_45,label_46 + char* label45 = (char*)calloc(1024, sizeof(char)); + char* label46 = (char*)calloc(1024, sizeof(char)); + char* button = (char*)calloc(1024, sizeof(char)); + + char* describeSelect2 = (char*)calloc(1024, sizeof(char)); + char* describeUpdate2 = (char*)calloc(1024, sizeof(char)); + char* label25 = (char*)calloc(1024, sizeof(char)); + char* button10 = (char*)calloc(1024, sizeof(char)); + + char* server_address; + + PREF_ask_char_value("TC11_SqlServer_Link_ITK", valueNum, &server_address); + + + //ȡ + EPM_ask_root_task(msg.task, &root_task); + //ȡĿļеĵǰ + EPM_ask_attachments(root_task, EPM_target_attachment, &count, &attachments);//count ΪĿļеĶ attachments Ϊǰݼ + //ȡ + //arg_cnt = TC_number_of_arguments(msg.arguments); + + for (int i = 0; i < count; i++) + { + ifail = AOM_ask_value_string(attachments[i], "object_type", &type_class); + printf("%s\n", type_class); + + //˵ǰ汾 + if ((strstr(type_class, "Revision") == NULL) || (strstr(type_class, "Master") != NULL) + || (strstr(type_class, "master") != NULL) || (strstr(type_class, "BOM") != NULL) || (strstr(type_class, "bom") != NULL) || (strstr(type_class, "Bom") != NULL)) + { + continue; + } + + ifail = AOM_ask_value_string(attachments[i], "item_id", &item_id); //õitemRevid + printf("%s\n", item_id); + AOM_ask_value_tags(attachments[i], "IMAN_master_form_rev", &item_mast_rev_count, &item_mast_rev); + printf("ȡ\n"); + //PROPDESC_ask_lov + //AOM_UIF_ask_value(item_mast_rev[0], "gd6_ddlx", &part_type); + AOM_UIF_ask_value(item_mast_rev[0], "gd6_ddlx", &part_type);//͵ֵ + + printf("%s\n", part_type); + + //ifail = ITEM_find_item(item_id, &item_tag); + //cout << item_tag << endl; + + + ITK__convert_tag_to_uid(attachments[i], &puid); + + printf("%s\n", puid); + + //printf("puidΪ:%s\n", puid); + + hr = m_pConnection.CreateInstance(_uuidof(Connection));//Ӷʵ + if (SUCCEEDED(hr)) + { + /* + Provider=SQLOLEDB.1 ------ݿoledbķʽbai + Persist Security Info ----Ƿ񱣴氲ȫϢdu + User ID-------------------û + PassWord------------------zhi + Initial Catalog-----------ݿƻݿipĿdao¼ + Data Source---------------Դ + */ + m_pConnection->ConnectionString = (server_address); + printf("\n==========================================================\n"); + hr = m_pConnection->Open("", "", "", adConnectUnspecified);//ݿ + if (FAILED(hr)) + { + printf("Open Failed!"); + return 1; + } + else + { + printf("ʼ޸Ŀؼ\n"); + printf("%s\n", puid); + CString strSql; + CString updateSql; + // strSql.Format(_T("INSERT INTO [ݿ].[dbo].[tb_Process_Bom]([LinesNo],[ItemCode],[ItemName],[DrawingNo],[ProcessName],[EquiNo],[EquiName],[Designer],[ItemType],[CustomerDrawingNo],[MBomCode],[Material],[ProcessOwner],[RevNo],[OBID],[SysNo],[State]) VALUES('%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s','%s','%s')"), LineID, ItemCode, ItemName, DrawingNo, ProcessName, EquiNo, EquiNames, Designer, Classify, CustomerDrawing, MBOMCode, MaterialNam, ProcessOwner, RevNo, OBID, SysNo, "UnCheck"); + //strSql.Format(_T("SELECT ENABLED FROM GD_CONTROLSTYPE_TABLE WHERE ORDER_TAGU = '%s' AND CONTROL_NAME = '%s'"), uid, control_name); + //char* describeSelect = (char*)calloc(1024, sizeof(char)); + //char* describeUpdate = (char*)calloc(1024, sizeof(char)); + ////label_45,label_46 + //char* label45 = (char*)calloc(1024, sizeof(char)); + //char* label46 = (char*)calloc(1024, sizeof(char)); + //char* button = (char*)calloc(1024, sizeof(char)); + //updateSql.Format(_T("UPDATE GD_CONTROLSTYPE_TABLE SET ENABLED ='%s' WHERE ORDER_TAGU = '%s' AND CONTROL_NAME = '%s'"), style, uid, control_name); + + sprintf(describeSelect, "SELECT ENABLED FROM GD_CONTROLSTYPE_TABLE WHERE ORDER_TAGU = '%s' AND CONTROL_NAME = 'btnDmu'", puid); + sprintf(describeUpdate, "UPDATE GD_CONTROLSTYPE_TABLE SET ENABLED ='false',BACKGROUND = 'GREEN' WHERE ORDER_TAGU = '%s' AND CONTROL_NAME = 'btnDmu'", puid); + sprintf(label45, "UPDATE GD_CONTROLSTYPE_TABLE SET BACKGROUND = 'GREEN' WHERE CONTROL_NAME = 'label_45' AND ORDER_TAGU = '%s'", puid); + sprintf(label46, "UPDATE GD_CONTROLSTYPE_TABLE SET BACKGROUND = 'GREEN' WHERE CONTROL_NAME = 'label_46' AND ORDER_TAGU = '%s'", puid); + sprintf(button, "UPDATE GD_CONTROLSTYPE_TABLE SET ENABLED ='true' WHERE ORDER_TAGU = '%s' AND CONTROL_NAME = 'button_3'", puid); + //sprintf(); + + /*char* describeSelect2 = (char*)calloc(1024, sizeof(char)); + char* describeUpdate2 = (char*)calloc(1024, sizeof(char)); + char* label25 = (char*)calloc(1024, sizeof(char)); + char* button10 = (char*)calloc(1024, sizeof(char));*/ + + sprintf(describeSelect2, "SELECT ENABLED FROM GD_CONTROLSTYPE_TABLE WHERE ORDER_TAGU = '%s' AND CONTROL_NAME = 'part_9'", puid); + sprintf(describeUpdate2, "UPDATE GD_CONTROLSTYPE_TABLE SET ENABLED ='false',BACKGROUND = 'GREEN' WHERE ORDER_TAGU = '%s' AND CONTROL_NAME = 'part_9'", puid); + sprintf(label25, "UPDATE GD_CONTROLSTYPE_TABLE SET BACKGROUND = 'GREEN' WHERE CONTROL_NAME = 'label25' AND ORDER_TAGU = '%s'", puid); + sprintf(button10, "UPDATE GD_CONTROLSTYPE_TABLE SET ENABLED ='true' WHERE ORDER_TAGU = '%s' AND CONTROL_NAME = 'part_10'", puid); + + + cout << describeSelect << endl; + cout << describeUpdate << endl; + cout << label45 << endl; + cout << label46 << endl; + cout << button << endl; + //printf(describeSelect); + //printf(describeUpdate); + //printf(label45); + //printf(label46); + try + { + printf("ѯʼ\n"); + //QuerySQLNoInputParam(describeSelect, &outputColumn, &outputValueCount, &outputValue); + //printf("״̬Ϊ: %s", **outputValue); + m_pRecordset.CreateInstance(__uuidof(Recordset)); + if (strcmp(part_type, "") == 0) { + printf("ѯ"); + m_pRecordset->Open(describeSelect, m_pConnection.GetInterfacePtr(), adOpenStatic, adLockOptimistic, adCmdText); + } + else { + m_pRecordset->Open(describeSelect2, m_pConnection.GetInterfacePtr(), adOpenStatic, adLockOptimistic, adCmdText); + } + + + while (!m_pRecordset->adoEOF) + { + printf("ѯdmuť״̬"); + //ѯdmuť״̬ + _variant_t taskStyle = NULL; + taskStyle = m_pRecordset->GetCollect("ENABLED"); + const char* str; + + _bstr_t bst_t = taskStyle; + + str = (const char*)bst_t; + + printf("ť״̬=======================%s\n", str); + + if (strcmp(str,"true") == 0) { + if (strcmp(part_type,"") == 0) { + m_pConnection->Execute(_bstr_t(describeUpdate), 0, adCmdText); + m_pConnection->Execute(_bstr_t(label45), 0, adCmdText); + m_pConnection->Execute(_bstr_t(label46), 0, adCmdText); + m_pConnection->Execute(_bstr_t(button), 0, adCmdText); + printf("½\n"); + } + else if (strcmp(part_type, "") == 0 ){ + m_pConnection->Execute(_bstr_t(describeUpdate2), 0, adCmdText); + m_pConnection->Execute(_bstr_t(label25), 0, adCmdText); + m_pConnection->Execute(_bstr_t(button10), 0, adCmdText); + printf("½\n"); + } + else { + printf("ûжӦ"); + break; + } + } + else { + break; + } + + m_pRecordset->MoveNext();///Ƶһ¼ + } + printf("ִн\n"); + + //if (strcmp(outputValue[0][0], "false") == 0) { + // printf("¿ʼ%s\n", outputValue[0][0]); + //m_pConnection->Execute(_bstr_t(describeUpdate), 0, adCmdText); + //m_pConnection->Execute(_bstr_t(label45), 0, adCmdText); + //m_pConnection->Execute(_bstr_t(label46), 0, adCmdText); + //m_pConnection->Execute(_bstr_t(updateDescribe), 0, adCmdText); + //printf("½\n"); + // return ifail; + //}; + } + catch (_com_error e) + { + printf(e.Description()); + return 1; + } + + //strSql = NULL; + //describe = NULL; + } + } + else + { + printf("Create instance of connection failed!"); + return 1; + + } + + } + DOFREE(attachments); + DOFREE(item_mast_rev); + DOFREE(item_id); + DOFREE(type_class); + DOFREE(part_type); + DOFREE(object_type); + DOFREE(puid); + describeSelect = NULL; + describeUpdate = NULL; + describeUpdate2 = NULL; + describeSelect2 = NULL; + label45 = NULL; + label46 = NULL; + label25 = NULL; + button = NULL; + button10 = NULL; + + return ifail; +} diff --git a/CONNOR_ITK/jl_insert_img_pdf.cxx b/CONNOR_ITK/jl_insert_img_pdf.cxx new file mode 100644 index 0000000..d48fbd9 --- /dev/null +++ b/CONNOR_ITK/jl_insert_img_pdf.cxx @@ -0,0 +1,1007 @@ + + +#include "epm_handler_common.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#pragma warning(disable : 4996) +#include +//־ +#include "common_itk_util.h" + +extern "C" int POM_AM__set_application_bypass(logical bypass); +using namespace std; + +int setTarget2(tag_t tag_task, tag_t tag_a) { + int ifail = ITK_ok; + int master_count = 0, count = 0; + int attachment_types = 0; + + if (tag_a != NULL) { + //AOM_unlock(tag_a); + attachment_types = EPM_target_attachment; + //attachment_types = EPM_reference_attachment; + + printf("ʼ汾Ŀ\n"); + EPM_add_attachments(tag_task, 1, &(tag_a), &attachment_types); + printf("汾Ŀ\n"); + //AOM_lock(tag_a); + return ITK_ok; + } +} + + +//ַָ +void split_img(char* src, const char* separator, char** dest, int* num) { + /* + src Դַ׵ַ(bufĵַ) + separator ָķַָ + dest ַ + num ַָĸ + */ + char* pNext; + int count = 0; + if (src == NULL || strlen(src) == 0) //ĵַΪջ򳤶Ϊ0ֱֹ + return; + if (separator == NULL || strlen(separator) == 0) //δֱַָָֹ + return; + pNext = (char*)strtok(src, separator); //ʹ(char *)ǿת(Ȼдеıвָ) + while (pNext != NULL) { + *dest++ = pNext; + ++count; + pNext = (char*)strtok(NULL, separator); //ʹ(char *)ǿת + } + *num = count; +} + +/** +*ݼݼJAVAͼƬ(pdf) +* +*/ +int insert_pdf(tag_t dataset, char *ext,char *second_tag_type, tag_t rootTask_tag) +{ + int ifail = ITK_ok; + printf("insert_pdf \r\n"); + tag_t spec_dataset_rev = NULLTAG, + ref_object = NULLTAG; + + AE_reference_type_t reference_type; + ITKCALL(ifail = AE_ask_dataset_latest_rev(dataset, &spec_dataset_rev)); + + char ref_name[WSO_name_size_c + 1] = ""; + if (strcmp(second_tag_type, "PDF") == 0) { + strcpy(ref_name,"PDF_Reference"); + ITKCALL(ifail = AE_ask_dataset_named_ref(spec_dataset_rev, ref_name, &reference_type, &ref_object)); + } + else { + strcpy(ref_name, "CAEAnalysisData"); + ITKCALL(ifail = AE_ask_dataset_named_ref(spec_dataset_rev, ref_name, &reference_type, &ref_object)); + + } + + if (reference_type == AE_PART_OF) + { + char pathname[SS_MAXPATHLEN] = ""; + //شTcFileļ··ĸʽȡڻ͵ֵ + ITKCALL(ifail = IMF_ask_file_pathname(ref_object, SS_WNT_MACHINE, pathname)); + char origin_file_name[IMF_filename_size_c + 1] = ""; + ITKCALL(ifail = IMF_ask_original_file_name(ref_object, origin_file_name)); + char new_ds_name[WSO_name_size_c + 1] = ""; + char *new_file_name = USER_new_file_name(new_ds_name, ref_name, ext, 0);//Ϊݼļ + //char *new_file_name = USER_new_file_name(new_ds_name, ref_name, "pdf", 0); + char *temp_dir = getenv("temp"); //C:\Windows\temp + char * tc_root_dir = getenv("tc_root"); //C:\Siemens\Teamcenter11 + char img_file[SS_MAXPATHLEN] = ""; + char temp_file[SS_MAXPATHLEN] = ""; + char temp_file2[SS_MAXPATHLEN] = ""; + char jar_file[SS_MAXPATHLEN] = ""; + //----------------------------- + strcpy(temp_file, temp_dir); + strcat(temp_file, "\\"); + strcat(temp_file, new_file_name); //C:\Windows\temp\\new_ds_name.pdf · + //printf("pdf·֣ %s\n",temp_file); + //-------------------------- + strcpy(temp_file2, temp_dir); + strcat(temp_file2, "\\"); + strcat(temp_file2, new_file_name); + strcat(temp_file2, ".pdf"); //C:\Windows\temp\\new_ds_name.pdf.pdf · + //printf("pdf·֣ %s\n", temp_file); + //-----------------------------4 + strcpy(img_file, tc_root_dir); + //strcat(img_file, "\\bin\\"); + strcat(img_file, "\\"); + strcat(img_file, "sign.jpg"); //C:\Siemens\Teamcenter11\\bin + //----------------------------- + strcpy(jar_file, tc_root_dir); + strcat(jar_file, "\\bin\\"); + strcat(jar_file, "insert_pdf.jar"); + + //TcFileϵͳе··ڵǰĿ¼(file_tag,pathname) + ITKCALL(ifail = IMF_export_file(ref_object, temp_file)); + ITKCALL(ifail = IMF_export_file(ref_object, temp_file2)); + int iCnt; + char *user_lib_env, pTempStr[500]; + char local_path[MAX_PATH] = ""; + char cmd[256] = ""; + strcpy(cmd, "java -jar \""); + strcat(cmd, jar_file); + strcat(cmd, "\" \""); + strcat(cmd, temp_file2); + strcat(cmd, "\" \""); + strcat(cmd, temp_file); + strcat(cmd, "\""); + printf("\n%s\n", cmd); + system(cmd); + + tag_t new_file_tag = NULLTAG; + IMF_file_t file_descriptor; + + ITKCALL(ifail = IMF_import_file(temp_file, new_file_name, SS_BINARY, &new_file_tag, &file_descriptor)); + AOM_lock(new_file_tag); + ITKCALL(ifail = IMF_set_original_file_name(new_file_tag, origin_file_name)); + ITKCALL(ifail = IMF_close_file(file_descriptor)); + ITKCALL(ifail = AOM_save(new_file_tag)); + AOM_unlock(new_file_tag); + AOM_refresh(new_file_tag,TRUE); + AOM_lock(spec_dataset_rev); + AE_remove_dataset_named_ref_by_tag(spec_dataset_rev, ref_name, ref_object); + AE_add_dataset_named_ref(spec_dataset_rev, ref_name, AE_PART_OF, new_file_tag); + AOM_save(spec_dataset_rev); + AOM_unlock(spec_dataset_rev); + AOM_refresh(spec_dataset_rev,TRUE); + } + + return ITK_ok; +} +/** + wordˮӡ +*/ +int insert_word(tag_t dataset, char* ext,char *type,tag_t rev,tag_t rootTask_tag,char* folder_name) +{ + printf("wordˮӡʼתpdfʼ \r\n"); + tag_t spec_dataset_rev = NULLTAG, + ref_object = NULLTAG, + ref_object2 = NULLTAG; + char* object_name = NULL; + AE_reference_type_t reference_type; + AE_reference_type_t reference_type2; + //ITKCALL(AE_ask_dataset_latest_rev(dataset, &spec_dataset_rev)); + AE_ask_dataset_latest_rev(dataset, &spec_dataset_rev); + char ref_name[WSO_name_size_c + 1] = "word"; + char ref_name2[WSO_name_size_c + 1] = "PDF_Reference"; + //ITKCALL(AE_ask_dataset_named_ref(spec_dataset_rev, ref_name, &reference_type, &ref_object)); + AE_ask_dataset_named_ref(spec_dataset_rev, ref_name, &reference_type, &ref_object); + + AOM_ask_value_string(dataset,"object_name",&object_name); //ԭwordݼobject_name + printf("wordԭΪ%s",object_name); + //ͬpdfִ + tag_t relation_type , *second_tags; + int second_tags_count = 0; + char *other_name = NULL,*other_type = NULL ,self_name[WSO_name_size_c + 1] = "",self_new_name[WSO_name_size_c + 1] = "";//ȥ׺֮word + int self_num = 0; + char* revbuf_test[8] = { }; //ŷַָ + strcpy(self_name,object_name); + + printf("wordԭΪ%s\n",self_name); + if(strstr(self_name,".") > 0){ + split_img(self_name,".", revbuf_test, &self_num); + for(int i=0;i 0){ + split_img(object_name, ".", revbuf, &tc_num); + for(int m=0;m 0){ + split_img(self_name,".", revbuf_test, &self_num); + for(int i=0;i 0){ + split_img(object_name, ".", revbuf, &tc_num); + for(int m=0;m %s \r\n", second_tag_type);// second_tag_type => MSWordX + if(second_tag_type == NULL){ + return; + } + + if (strcmp(second_tag_type, "PDF") == 0 || strcmp(second_tag_type, "CAEAnalysisDS") == 0) { + insert_pdf(second_tags, "pdf",second_tag_type, rootTask_tag); + printf("%s\n", "pdfˮӡӳɹ"); + //setTarget2(rootTask_tag, tag_tags[m]);//汾Ŀ + } + else if (strcmp(second_tag_type, "MSWordX") == 0) + { + insert_word(second_tags, "word",".docx", rev, rootTask_tag,folder_name); + printf("wordˮӡӳɹ\n"); + } + else if (strcmp(second_tag_type, "MSWord") == 0) + { + insert_word(second_tags, "word", ".doc", rev, rootTask_tag,folder_name); + printf("wordˮӡӳɹ\n"); + } + else if (strcmp(second_tag_type, "MSExcelX") == 0 ) { + + insert_excel(second_tags, "excel",".xlsx", rev, rootTask_tag,folder_name); + printf("excelˮӡӳɹ\n"); + } + else if (strcmp(second_tag_type, "MSExcel") == 0) + { + insert_excel(second_tags, "excel", ".xls", rev, rootTask_tag,folder_name); + printf("excelˮӡӳɹ\n"); + } + + if (second_tag_type != NULL) { + MEM_free(second_tag_type); + second_tag_type = NULL; + } +} + + +/** +*PDFвͼƬhandler +* +*/ +int jl_insert_img_pdf(EPM_action_message_t msg) +{ + char* log_file = NULL; + char log_path[128] = "C:\\Temp\\jl_insert_img_pdf_LOG.txt"; + CreateLogFile(log_path, &log_file); + + //printf("%s\n","pdfͼƬʼ"); + WriteLog("pdfͼƬʼ"); + // + POM_AM__set_application_bypass(true); + int ifail = ITK_ok, att_cnt = 0, i = 0; + tag_t task_tag = NULLTAG, + rootTask_tag = NULLTAG, + *attachments = NULL, + relation_type = NULLTAG, + relation_type1 = NULLTAG, + relation_type2 = NULLTAG, + relation_type3 = NULLTAG, + relation_type4 = NULLTAG, + relation_type5 = NULLTAG, + type_tag = NULLTAG; + char tgt_type[WSO_name_size_c + 1] = "", + type_class[TCTYPE_class_name_size_c + 1] = "", + rev_type[ITEM_type_size_c + 1] = ""; + map rev_map; + //ȡ + task_tag = msg.task; + WriteLog("ʼȡ"); + //ȡ + ITKCALL(ifail = EPM_ask_root_task(task_tag, &rootTask_tag)); + //ȡĿ + WriteLog("ʼĿµĶ"); + ITKCALL(ifail = EPM_ask_attachments(rootTask_tag, EPM_target_attachment, &att_cnt, &attachments)); + for (i = 0; i < att_cnt; i++) + { + WriteLog("ȡ"); + ITKCALL(ifail = TCTYPE_ask_object_type(attachments[i], &type_tag)); + ITKCALL(ifail = TCTYPE_ask_class_name(type_tag, type_class)); + printf("type_class : %s \r\n", type_class); + + //˵ǰ汾 + WriteLog("ʼ˵ǰ汾"); + if (((strstr(type_class, "Revision") != NULL) || (strstr(type_class, "revision") != NULL)) + && (strstr(type_class, "Master") == NULL) && (strstr(type_class, "master") == NULL) + && (strstr(type_class, "BOM") == NULL) && (strstr(type_class, "bom") == NULL) && (strstr(type_class, "Bom") == NULL)) + { + printf("coming"); + //汾д뵽 + WriteLog("˺İ汾д뵽"); + rev_map.insert(pair(attachments[i], "")); + } + } + + WriteLog("ʼϵ"); + ITKCALL(ifail = GRM_find_relation_type(TC_attaches_rtype, &relation_type)); + ITKCALL(ifail = GRM_find_relation_type(TC_specification_rtype, &relation_type1)); + ITKCALL(ifail = GRM_find_relation_type("catia_auxiliaryLink", &relation_type2)); + + ITKCALL(ifail = GRM_find_relation_type("Gd6_CPYQ1", &relation_type3)); + ITKCALL(ifail = GRM_find_relation_type("Gd6_KHSR", &relation_type4)); + + //ʼеİ汾 + WriteLog("ʼеİ汾"); + map::iterator rev_it; + for (rev_it = rev_map.begin(); rev_it != rev_map.end(); rev_it++) + { + WriteLog("еİ汾beginning\n"); + //ITKCALL(ITEM_ask_rev_type(rev_it->first, rev_type)); + ITEM_ask_rev_type(rev_it->first, rev_type); + tag_t * second_tagsAll = (tag_t *)MEM_alloc(sizeof(tag_t)); + + tag_t * second_tags = NULLTAG; + tag_t * second_tags1 = NULLTAG; + tag_t * second_tags2 = NULLTAG; + tag_t* second_tags3 = NULLTAG; + tag_t* second_tags4 = NULLTAG; + int second_tags_countAll = 0; + int second_tags_count = 0; + int second_tags_count1 = 0; + int second_tags_count2 = 0; + int second_tags_count3 = 0; + int second_tags_count4 = 0; + //ݼ߼ + ITKCALL(ifail = GRM_list_secondary_objects_only(rev_it->first, relation_type, &second_tags_count, &second_tags)); + ITKCALL(ifail = GRM_list_secondary_objects_only(rev_it->first, relation_type1, &second_tags_count1, &second_tags1)); + ITKCALL(ifail = GRM_list_secondary_objects_only(rev_it->first, relation_type2, &second_tags_count2, &second_tags2)); + + second_tags_countAll = second_tags_count + second_tags_count1 + second_tags_count2; + + + printf("%s\n", "111111111"); + WriteLog("ʼݵsecond_tagsAll \n"); + for (int i = 0; i < second_tags_count; i++) + { + WriteLog("second_tagsAll[i] = second_tagsAll[%d]",i); + second_tagsAll[i] = second_tags[i]; + } + for (int i = 0; i < second_tags_count1; i++) + { + WriteLog("second_tagsAll[i+second_tags_count] = second_tagsAll[%d]", i+second_tags_count); + second_tagsAll[i+second_tags_count] = second_tags1[i]; + } + for (int i = 0; i < second_tags_count2; i++) + { + WriteLog("second_tagsAll[i+second_tags_count+second_tags_count1] = second_tagsAll[%d]", i+second_tags_count+second_tags_count1); + second_tagsAll[i+second_tags_count+second_tags_count1] = second_tags2[i]; + } + + printf("%s\n", "111111111"); + + printf("second_tags_countAllΪ%d\n", second_tags_countAll); + WriteLog("second_tags_countAllΪ%d\n", second_tags_countAll); + char * carModel = NULL; + ITKCALL(ifail = AOM_ask_value_string(rev_it->first, "item_id", &carModel)); + printf("item_id=%s \n", carModel); + MEM_free(carModel); + for (i = 0; i < second_tags_countAll; i++) { + char * second_tag_type = NULL; + ITKCALL(ifail = AOM_ask_value_string(second_tagsAll[i], "object_type", &second_tag_type)); + printf(" second_tag_type => %s \r\n", second_tag_type);// second_tag_type => MSWordX + WriteLog("second_tag_type => %s \r\n", second_tag_type); + MEM_free(second_tag_type); + } + + for (i = 0; i < second_tags_countAll; i++) { + if(second_tagsAll[i]!=0&&second_tagsAll[i]!=NULL){ + changePdf(rev_it->first,rootTask_tag,second_tagsAll[i],""); + } + + } + if(strcmp(rev_type,"Gd6_CPYQRevision")==0){ + WriteLog("rev_type==Gd6_CPYQRevision \n ƷҪʼ\n"); + cout<<"ƷҪʼ"<first, relation_type3, &second_tags_count3, &second_tags3)); + for (int i = 0; i < second_tags_count3; i++) + { + changePdf(rev_it->first,rootTask_tag,second_tags3[i],"Gd6_CPYQ1"); + WriteLog("Gd6_CPYQ1\n"); + } + WriteLog("rev_type==Gd6_CPYQRevision \n ͻ뿪ʼ\n"); + cout<<"ͻ뿪ʼ"<first, relation_type4, &second_tags_count4, &second_tags4)); + + for (int i = 0; i < second_tags_count4; i++) + { + WriteLog("Gd6_KHSR\n"); + changePdf(rev_it->first,rootTask_tag,second_tags4[i],"Gd6_KHSR"); + } + } + + printf("kkk\n"); + WriteLog("ִнǰͷŶ\n"); + if (second_tags) { + WriteLog("ͷsecond_tags\n"); + MEM_free(second_tags); + second_tags = NULL; + } + if (second_tags1) { + WriteLog("ͷsecond_tags1\n"); + MEM_free(second_tags1); + second_tags1 = NULL; + } + if (second_tags2) { + WriteLog("ͷsecond_tags2\n"); + MEM_free(second_tags2); + second_tags2 = NULL; + } + if (second_tags3) { + WriteLog("ͷsecond_tags3\n"); + MEM_free(second_tags3); + second_tags3 = NULL; + } + if (second_tags4) { + WriteLog("ͷsecond_tags4\n"); + MEM_free(second_tags4); + second_tags4 = NULL; + } + + } + + printf("ksaskk\n"); + if (attachments != NULL) { + WriteLog("ͷattachments\n"); + MEM_free(attachments); + attachments = NULL; + } + POM_AM__set_application_bypass(false); + printf("ˮӳ\n"); + WriteLog("ִн\n"); + CloseLog(); + return ifail; +} + + diff --git a/CONNOR_ITK/jl_insert_modular.cxx b/CONNOR_ITK/jl_insert_modular.cxx new file mode 100644 index 0000000..21fc86c --- /dev/null +++ b/CONNOR_ITK/jl_insert_modular.cxx @@ -0,0 +1,196 @@ + + +#include "epm_handler_common.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#pragma warning(disable : 4996) +#include + + +extern "C" int POM_AM__set_application_bypass(logical bypass); +using namespace std; + + +int jl_insert_modular(EPM_action_message_t msg) +{ + printf("Ϳʼ"); + int ifail = ITK_ok, att_cnt = 0,i=0, item_mast_rev_count = 0,ico_att_count ,*ico_id_count,*ico_values_count; + tag_t task_tag = NULLTAG, + rootTask_tag = NULLTAG, + type_tag = NULLTAG, + old_ico_tag = NULLTAG, + new_ico_tag = NULLTAG, + item_class_tag = NULLTAG, + item_class_tag2 = NULLTAG, + rev_tag = NULLTAG, classificationObject; + + tag_t *attachments = NULLTAG, *item_mast_rev = NULLTAG ; + logical verdict; + + char* type_value = NULL, * bom_value = NULL, * orderType_value = NULL, *item_id = NULL,**ico_values,**ico_attribute,***ico_values2, + oldClassID[TCTYPE_class_name_size_c + 1], newClassID[TCTYPE_class_name_size_c + 1]; + //ȡ + task_tag = msg.task; + //ȡ + ifail = EPM_ask_root_task(task_tag,&rootTask_tag); + //ȡĿ + ifail = EPM_ask_attachments(rootTask_tag, EPM_target_attachment, &att_cnt, &attachments); + + for (i = 0; i < att_cnt; i++) { + printf("ѭʼ"); + //õĿ + ifail = TCTYPE_ask_object_type(attachments[i], &type_tag); + //õĿ°汾 + //ifail = ITEM_ask_item_of_rev(attachments[i],&rev_tag); + ifail = ITEM_ask_latest_rev(attachments[i], &rev_tag); + + //AOM_UIF_ask_value(); + //ITEM_ask_type(); + //ITEM_ask_rev_master_form_type + ifail = AOM_ask_value_string(attachments[i], "object_type", &type_value); //õitem + printf("object_typeΪ%s\n", type_value); + ifail = AOM_ask_value_string(attachments[i], "item_id", &item_id); //õitemid + printf("item_idΪ%s\n", item_id); + + //õ汾µ + AOM_ask_value_tags(rev_tag, "IMAN_master_form_rev", &item_mast_rev_count, &item_mast_rev); + //printf("testΪ%s\n", item_mast_rev[0]); + + AOM_ask_value_string(item_mast_rev[0], "user_data_1", &bom_value);//ԡbom״ֵ̬ + AOM_ask_value_string(item_mast_rev[0], "user_data_2", &orderType_value);//͵ֵ + printf("user_data_1Ϊ%s\n", bom_value); + printf("user_data_2Ϊ%s\n", orderType_value); + + + //õid(ͨ͵ֵ) + if (strcmp(orderType_value, "") == 0) { + strcpy(oldClassID,"jlcs010201"); + strcpy(newClassID,"jlcs010101"); + printf("idΪ %s", oldClassID); + } + else if (strcmp(orderType_value, "") == 0) + { + strcpy(oldClassID, "jlcs010202"); + strcpy(newClassID, "jlcs010102"); + printf("idΪ %s", oldClassID); + } + else if (strcmp(orderType_value, "KD") == 0) + { + strcpy(oldClassID, "jlcs010203"); + strcpy(newClassID, "jlcs010103"); + printf("idΪ %s", oldClassID); + } + + if (strcmp(type_value,"Gd6_Order")!=0) { + printf("öͲǶ \n"); + } + else { + printf("öǶ \n"); + + } + + //ITK_ask_cli_argument(); + //ITK__convert_uid_to_tag(); + POM_AM__set_application_bypass(true); + if (strcmp(bom_value,"·ɹ")==0) { + //ICS_find_class() + //ITK__convert_uid_to_tag + printf("࿪ʼ \n"); + //ICS_ask_classification_object(attachments[i],&itemClass_tag); //ͨitemõitemķ + + + ICS_is_wsobject_classified(attachments[i],&verdict); //˺ĹǷѷࡣ + + /*⽫ݶidͼ/Ǻ͹ռ󴴽һµķ + ws_object#NULLTAGICOԸöзࡣ£ + idԣws_idICO id + ws_object#NULLTAG򽫴һICOidΪobject#id + ע⣺ҪΪ֧ԪϵͳഴICOʹICS ICO*/ + //ICS_create_classification_object(); + + //ȡɸIDַʶ/ıǡ + ICS_find_class(oldClassID, &old_ico_tag); //ԭtag idж + ICS_find_class(newClassID, &new_ico_tag); //ʷеķtag id + printf("tag %d\n", old_ico_tag); + cout << new_ico_tag << endl; + //cout << itemClass_tag << endl; + + ICS_ask_classification_object(attachments[i],&item_class_tag); + + //ICS_attribute_convert_attribute_values(); + + + ICS_ico_ask_attributes(item_class_tag,&ico_att_count ,&ico_id_count, &ico_values_count,&ico_values2); + cout << ico_att_count << endl; + cout << *ico_id_count << endl; + cout << *ico_values_count << endl; + cout << ico_values2 << endl; + //ICS_ask_attributes_of_classification_obj(item_class_tag, &ico_att_count, &ico_attribute,&ico_values); + //ICS_attribute_set_property(); + //ICS_attribute_ask_id; + + //ICS_remove_classification() //ȫɾitemͷеĶ + //ICS_delete_reference_to_wsobject + ICS_delete_reference_to_ico(item_class_tag); + + ICS_delete_classification_object(item_class_tag); + + //char** value = (char**)MEM_alloc(sizeof(char*)); + + ICS_create_classification_object(attachments[i],item_id, new_ico_tag, &classificationObject); + //˺ԸĹз࣬ʹIMAN_ϵĸ + ICS_classify_wsobject(attachments[i], classificationObject); + //ICS_ico_ask_attributes(item_class_tag, &ico_att_count, &ico_id_count, &ico_values_count, &ico_values2); + + ICS_ask_classification_object(attachments[i],&item_class_tag2); + ICS_ico_set_attributes(item_class_tag2, ico_att_count, ico_id_count, ico_values_count,(const char*** )ico_values2); + printf("Ƶʷɹ"); + POM_AM__set_application_bypass(false); + //MEM_free(oldClassID); + //MEM_free(newClassID); + } + else { + printf("͵ʧ"); + } + } + + return ifail; +} +////ȡ REVISION Ӧķ +//ICS_ask_classification_object(top_rev_tag,&top_classificationObject); +//if(top_classificationObject == NULL_TAG) +//{ +//printf("ûз͵\n"); +//return 0; +//} +//ICS_ask_class_of_classification_obj(top_classificationObject,&top_class_tag); +//ICS_ask_id_name(top_class_tag, &top_class_id, &top_class_name); +//char *revbuf1[8] = { 0 }; +//int num1 = 0; +//split(bl_formatted_parent_name, "/", revbuf1, &num1); +//ICS_create_classification_object +//ICS_is_wsobject_classified( +// ICS_classify_wsobject +//AOM_UIF_ask_value(); + diff --git a/CONNOR_ITK/jl_locomotion_item.cxx b/CONNOR_ITK/jl_locomotion_item.cxx new file mode 100644 index 0000000..101a7ae --- /dev/null +++ b/CONNOR_ITK/jl_locomotion_item.cxx @@ -0,0 +1,140 @@ +#include "epm_handler_common.h" +#include +#include +#include +//#include "string_helper.cpp" +#include +#include +#include +#include + +using namespace std; + +#define DOFREE(obj) \ +{ \ + if(obj) \ + { \ + MEM_free(obj); \ + obj = NULL; \ + } \ +} + +extern "C" int POM_AM__set_application_bypass(logical bypass); +int jl_locomotion_item(EPM_action_message_t msg) { + + + printf("==================ƶָļ START =======================\n"); + int ifail = EPM_go, count = 0, arg_cnt = 0; + + tag_t root_task = NULL_TAG; + + tag_t* attachments = NULL; + + + //ȡ + EPM_ask_root_task(msg.task, &root_task); + //ȡĿļеĶ + EPM_ask_attachments(root_task, EPM_target_attachment, &count, &attachments); + //ȡ + arg_cnt = TC_number_of_arguments(msg.arguments); + + /* + if (arg_cnt > 0) + { + for (int i = 0; i < arg_cnt; i++) + { + arg = TC_next_argument(msg.arguments); + //ITKCALL(ifail = ITK_ask_argument_named_value((const char*)arg, &argflag, &argvalue)); + ifail = ITK_ask_argument_named_value((const char*)arg, &argflag, &argvalue); + if (stricmp(argflag, "ItemType") == 0) + { + if (argvalue != NULL) + { + strcpy(arg1value, argvalue); + } + } + } + MEM_free(argflag); + MEM_free(argvalue); + } + */ + + for (int i = 0; i < count; i++) + { + int count1 = 0, count2 = 0, count3 = 0; + tag_t* target1, * target2, * target3; + + int itemCount = 0, n_references = 0, items_tagCount = 0, item_mast_rev_count = 0; + char * type_class = NULL; + //int * levels = NULL; + //char **relation_type_name = NULL; * reference_tags = NULL, + + tag_t spec_relation1 = NULLTAG, spec_relation2 = NULLTAG, spec_relation3 = NULLTAG,spec_relation4 = NULLTAG ; + tag_t items_tag = NULL_TAG; + //tag_t spec_relation11 , spec_relation21, spec_relation31; + tag_t relation1, relation2, relation3; + + ifail = AOM_ask_value_string(attachments[i], "object_type", &type_class); + + printf("type_class : %s\n", type_class); + + //˵ǰ汾 + if ((strstr(type_class, "Revision") == NULL) || (strstr(type_class, "Master") != NULL) + || (strstr(type_class, "master") != NULL) || (strstr(type_class, "BOM") != NULL) || (strstr(type_class, "bom") != NULL) || (strstr(type_class, "Bom") != NULL)) + { + continue; + } + + //ȡ + + ifail = ITEM_ask_item_of_rev(attachments[i], &items_tag); + + + GRM_find_relation_type("Gd6_BGLBJ", &spec_relation1); //㲿 + GRM_find_relation_type("Gd6_SYXLBJ", &spec_relation2); //Ӱ㲿 + GRM_find_relation_type("Gd6_XGFJ", &spec_relation3); //㲿 + + GRM_find_relation_type("Gd6_GLBGJ", &spec_relation4); //ظ + + GRM_list_secondary_objects_only(attachments[i], spec_relation1, &count1, &target1); + if (count1!=0) { + printf("ʼ\n"); + for (int j = 0; j < count1; j++) + { + //GRM_find_relation_type("Gd6_GYWJ", &spec_relation11); + GRM_create_relation(target1[j], items_tag, spec_relation4, NULLTAG, &relation1); + GRM_save_relation(relation1); + } + printf("\n"); + } + GRM_list_secondary_objects_only(attachments[i], spec_relation2, &count2, &target2); + if (count2 != 0) { + for (int j = 0; j < count2; j++) + { + //GRM_find_relation_type("Gd6_GYWJ", &spec_relation21); + GRM_create_relation(target2[j], items_tag, spec_relation4, NULLTAG, &relation2); + GRM_save_relation(relation2); + } + } + GRM_list_secondary_objects_only(attachments[i], spec_relation3, &count3, &target3); + if (count3 != 0) { + for (int j = 0; j < count3; j++) + { + //GRM_find_relation_type("Gd6_GYWJ", &spec_relation31); + GRM_create_relation(target3[j], items_tag, spec_relation4, NULLTAG, &relation3); + GRM_save_relation(relation3); + } + } + DOFREE(target1); + DOFREE(target2); + DOFREE(target3); + DOFREE(type_class); + + } + DOFREE(attachments); + + printf("==================ƶָļ END =======================\n"); + return ITK_ok; + + +} \ No newline at end of file diff --git a/CONNOR_ITK/ocilib.cxx b/CONNOR_ITK/ocilib.cxx new file mode 100644 index 0000000..2868d71 --- /dev/null +++ b/CONNOR_ITK/ocilib.cxx @@ -0,0 +1,439 @@ +/*===================================================================================================================== + Copyright(c) 2012 ORIGIN. + Unpublished - All rights reserved +======================================================================================================================= +File description: + + Filename: ocilib.cxx + Module : OCI + + This file describes OCI library Package. + +======================================================================================================================= +Date Name Description of Change +1-Feb-2015 Ray li Initialize creation +$HISTORY$ +=====================================================================================================================*/ +#include "ocilib.h" +#include + +#define NUM 100 +#define USERNAME "infodba" +#define PASSWORD "infodba" +#define DBNAME "tc" + + +// ṹ +typedef struct { + OCIEnv* p_env; //OCI environment handle + OCIError* p_err; //OCI error handle + OCISvcCtx* p_svc; //OCI service context handel ľ + OCIServer* p_ser; //OCI server handle + OCISession* p_usr; //OCI user session handle ûỰ + OCIStmt* p_sql; //OCI statement handle + OCIDefine* p_dfn; //OCI define handle + OCIBind* p_bnd; //OCI bind handle 󶨾 +}OCIHandleInfo; + + +// ṹ +typedef struct { + OCIEnv* p_env; + OCIError* p_err; + OCISvcCtx* p_svc; + OCIStmt* p_sql; + OCIDefine* p_dfn; + OCIBind* p_bnd; +}OCIDATA; + + +// ִʱ +typedef struct { + char value[NUM][NUM]; + char type[NUM][NUM]; +}SqlField; + + +// ѯʱ, +typedef struct { + int naIntValue[NUM]; + int nIntNum; + char caCharValue[500][500]; + int nCharNum; +}SqlSelField; + +OCIHandleInfo* ociHandle = NULL; +OCIHandleInfo ociHand; + +int InitHandle(); +int _ExeSQL(char* SQL, char** inputValue, int inputValueCount); +int _QuerySQL(char* SQL, SqlSelField* pOutField, SqlSelField* pSelField); +int GetDataFromQuery(int* pRc, SqlSelField* pOutField); +void QuitFreeHandle(); + + + + +/**************************************************************************************************************************************** +ƣ +ܣ +ڲ +ڲ + ע +*****************************************************************************************************************************************/ + + +// ʼHandler +int InitHandle() +{ + int swResult; + + ociHandle = &ociHand; + + + /*create OCI environment*/ + if (swResult = OCIEnvCreate(&ociHandle->p_env, OCI_DEFAULT, NULL, NULL, NULL, NULL, 0, NULL)) // + { + printf("environment create error!\n\n"); + return -1; + } + else + { + printf("environment create success!\n\n"); + //return 0; + } + + /*init handle*/ + if (swResult = OCIHandleAlloc(ociHandle->p_env, (dvoid**)&ociHandle->p_ser, OCI_HTYPE_SERVER, 0, NULL)) // + { + printf("init server handle error!\n\n"); + return -1; + } + + + if (swResult = OCIHandleAlloc(ociHandle->p_env, (dvoid**)&ociHandle->p_err, OCI_HTYPE_ERROR, 0, NULL)) // + { + printf("init error handle error!\n\n"); + return -1; + } + + + if (swResult = OCIHandleAlloc(ociHandle->p_env, (dvoid**)&ociHandle->p_usr, OCI_HTYPE_SESSION, 0, NULL)) // + { + printf("init session handle error!\n\n"); + return -1; + } + + + if (swResult = OCIHandleAlloc(ociHandle->p_env, (dvoid**)&ociHandle->p_svc, OCI_HTYPE_SVCCTX, 0, NULL)) //ľ + { + printf("init service context handle error!\n\n"); + return -1; + } + + + if (swResult = OCIHandleAlloc(ociHandle->p_env, (dvoid**)&ociHandle->p_sql, OCI_HTYPE_STMT, 0, NULL)) //SQL + { + printf("init statement handle error!\n\n"); + return -1; + } + + printf("init handle success!\n\n"); + + return 0; +} + + + +// ݿ +int ConnServer(char* username, char* password, char* dbname) +{ + int swResult; + char errbuf[100] = { 0 }; + int errcode; + + if (InitHandle() == -1)//ʼ + return -1; + + if (swResult = OCILogon(ociHandle->p_env, ociHandle->p_err, &ociHandle->p_svc, (text*)username, strlen(username), (text*)password, strlen(password), (text*)dbname, strlen(dbname))) + { + OCIErrorGet((dvoid*)ociHandle->p_err, (ub4)1, (text*)NULL, &errcode, (ub1*)errbuf, (ub4)sizeof(errbuf), OCI_HTYPE_ERROR); + printf("Error - %.*s/n", 512, errbuf); + return -1; + } + else + printf("ݿӳɹ!\n\n"); + return 0; +} + + + +// SQLij(ִSQL) +int _ExeSQL(char* SQL, char** inputValue, int inputValueCount) +{ + int swResult, i; + int errcode; + + //ð󶨱 + OCIBind* p_bndp[100]; + + //׼SQL + if (swResult = OCIStmtPrepare(ociHandle->p_sql, ociHandle->p_err, (text*)SQL, strlen(SQL), OCI_NTV_SYNTAX, OCI_DEFAULT)) + { + printf("prepare SQL statements error!\n\n"); + } + else + { + printf("prepare SQL statements success!\n\n"); + } + + + // + for (i = 0; i < inputValueCount; i++) + { + char errbuf[100] = { 0 }; + if (swResult = OCIBindByPos(ociHandle->p_sql, &p_bndp[i], ociHandle->p_err, i + 1, (dvoid*)inputValue[i], (sb4)strlen(inputValue[i]) + 1, SQLT_STR, (dvoid*)0, (ub2*)0, (ub2*)0, (ub4)0, (ub4*)0, OCI_DEFAULT)) + { + OCIErrorGet((dvoid*)ociHandle->p_err, (ub4)1, (text*)NULL, &errcode, (ub1*)errbuf, (ub4)sizeof(errbuf), OCI_HTYPE_ERROR); + printf("Bind Error - %.*s/n", 512, errbuf); + return -1; + } + } + + //ִSQL statements + if (swResult = OCIStmtExecute(ociHandle->p_svc, ociHandle->p_sql, ociHandle->p_err, 1, 0, NULL, NULL, OCI_DEFAULT | OCI_COMMIT_ON_SUCCESS)) + { + char errbuf[100] = { 0 }; + OCIErrorGet((dvoid*)ociHandle->p_err, (ub4)1, (text*)NULL, &errcode, (ub1*)errbuf, (ub4)sizeof(errbuf), OCI_HTYPE_ERROR); + printf("execute SQL statement Error - %.*s\n", 512, errbuf); + return -1; + } + else + { + printf("execute SQL statement success!\n\n"); + } + return 0; +} + + + + +// ѯSQL +int _QuerySQL(char* SQL, SqlSelField* pOutField, SqlSelField* pSelField) +{ + sword status; + int rc = 0, ret = 0; + char errbuf[100] = { 0 }; + int maxNum = 2048; + char chTag[8]; + int iIndex = 0; + int outputColumn = 0; + int errcode = 0; + char nullValue = '\0'; // + sb2 sb2aInd[30] = { '\0' }; + + // ׼SQL + status = OCIStmtPrepare(ociHandle->p_sql, ociHandle->p_err, (text*)SQL, (ub4)strlen(SQL), (ub4)OCI_NTV_SYNTAX, (ub4)OCI_DEFAULT); + + if (status != OCI_SUCCESS) + { + printf("SQL Preparing failed/n"); + return -1; + } + + + // int͵, SQLʱ :1,:2, + for (iIndex = 0; iIndex < pSelField->nIntNum; iIndex++) + { + memset(chTag, 0, 8); + sprintf(chTag, ":%d", iIndex + 1); + if (rc = OCIBindByName(ociHandle->p_sql, (OCIBind**)&ociHandle->p_dfn, ociHandle->p_err, (text*)chTag, (sb4)strlen((char*)chTag), (dvoid*)&pSelField->naIntValue[iIndex], sizeof(int), SQLT_INT, (dvoid*)0, (ub2*)0, (ub2*)0, (ub4)0, (ub4*)0, OCI_DEFAULT)) + { + OCIErrorGet((dvoid*)ociHandle->p_err, (ub4)1, (text*)NULL, &errcode, (ub1*)errbuf, (ub4)sizeof(errbuf), OCI_HTYPE_ERROR); + printf("BindByPos Error of ociHandle->p_sql - %.*s\n", 512, errbuf); + return -1; + } + } + + // char *͵, SQLʱ :3,:4, + for (iIndex = 0; iIndex < pSelField->nCharNum; iIndex++) + { + int n = 0; + memset(chTag, 0, 8); + n = pSelField->nIntNum + iIndex + 1; + sprintf(chTag, ":%d", n); + if (rc = OCIBindByName(ociHandle->p_sql, (OCIBind**)&ociHandle->p_dfn, ociHandle->p_err, (text*)chTag, (sb4)strlen((char*)chTag), (dvoid*)&pSelField->caCharValue[iIndex], NUM, SQLT_STR, (dvoid*)0, (ub2*)0, (ub2*)0, (ub4)0, (ub4*)0, OCI_DEFAULT)) + { + OCIErrorGet((dvoid*)ociHandle->p_err, (ub4)1, (text*)NULL, &errcode, (ub1*)errbuf, (ub4)sizeof(errbuf), OCI_HTYPE_ERROR); + printf("BindByPos Error of ociHandle->p_sql - %.*s\n", 512, errbuf); + return -1; + } + } + + + // ִSQL + if (rc = OCIStmtExecute(ociHandle->p_svc, ociHandle->p_sql, ociHandle->p_err, (ub4)0, (ub4)0, (CONST OCISnapshot*) NULL, (OCISnapshot*)NULL, OCI_STMT_SCROLLABLE_READONLY)) + { + OCIErrorGet((dvoid*)ociHandle->p_err, (ub4)1, (text*)NULL, &errcode, (ub1*)errbuf, (ub4)sizeof(errbuf), OCI_HTYPE_ERROR); + printf("execute SQL Error - %.*s\n", 512, errbuf); + return -1; + } + else + { + printf("execute SQL success!\n\n"); + } + + + if (ret = OCIAttrGet(ociHandle->p_sql, (ub4)OCI_HTYPE_STMT, (dvoid*)&outputColumn, (ub4*)0, (ub4)OCI_ATTR_PARAM_COUNT, ociHandle->p_err)) + { + OCIErrorGet((dvoid*)ociHandle->p_err, (ub4)1, (text*)NULL, &errcode, (ub1*)errbuf, (ub4)sizeof(errbuf), OCI_HTYPE_ERROR); + printf("Get OCIAttr Error of ociHandle->p_sql - %.*s\n", 512, errbuf); + return -1; + } + + + // int͵, SQLʱ :1,:2, + for (iIndex = 0; iIndex < pOutField->nIntNum; iIndex++) + { + if (rc = OCIDefineByPos(ociHandle->p_sql, &ociHandle->p_dfn, ociHandle->p_err, iIndex + 1, (dvoid*)&pOutField->naIntValue[iIndex], sizeof(int), SQLT_INT, (dvoid*)0, (ub2*)0, (ub2*)0, OCI_DEFAULT)) + { + OCIErrorGet((dvoid*)ociHandle->p_err, (ub4)1, (text*)NULL, &errcode, (ub1*)errbuf, (ub4)sizeof(errbuf), OCI_HTYPE_ERROR); + printf("DefineByPos Error of ociHandle->p_sql - %.*s\n", 512, errbuf); + return -1; + } + } + + + // char *͵, SQLʱ :1,:2, + for (iIndex = 0; iIndex < outputColumn; iIndex++) + { + int n = iIndex + 1; + if (rc = OCIDefineByPos(ociHandle->p_sql, &ociHandle->p_dfn, ociHandle->p_err, n, (dvoid*)&pOutField->caCharValue[iIndex], 1000 * sizeof(char), SQLT_STR, (dvoid*)0, (ub2*)0, (ub2*)0, OCI_DEFAULT)) + { + OCIErrorGet((dvoid*)ociHandle->p_err, (ub4)1, (text*)NULL, &errcode, (ub1*)errbuf, (ub4)sizeof(errbuf), OCI_HTYPE_ERROR); + printf("DefineByPos Error of ociHandle->p_sql - %.*s\n", 512, errbuf); + return -1; + } + } + + return 0; + +} + + + +// ͷHandler +void QuitFreeHandle() +{ + // ˳ + OCILogoff(ociHandle->p_svc, ociHandle->p_err); + printf("Quit success!\n"); + + // ͷž + OCIHandleFree(ociHandle->p_ser, OCI_HTYPE_SERVER); //ͷŷ + OCIHandleFree(ociHandle->p_err, OCI_HTYPE_ERROR); //ͷŴ + OCIHandleFree(ociHandle->p_usr, OCI_HTYPE_SESSION); //ͷ + OCIHandleFree(ociHandle->p_svc, OCI_HTYPE_SVCCTX); //ͷľ + OCIHandleFree(ociHandle->p_sql, OCI_HTYPE_STMT); //ͷSQL +} + + +// ִ +int ExecuteSQL(char* SQL, int valueCount, char** value) +{ + int i = 0; + + if (i = _ExeSQL(SQL, value, valueCount)) + { + QuitFreeHandle(); + return -1; + } + + return 0; +} + + +// IJѯ +int QuerySQL(char* SQL, int inputValueCount, char** inputValue, int* outputColumn, int* outputValueCount, char**** outputValue) +{ + int i = 0, j = 0, ret = 0; + + int times = 0, temp = 0; + + SqlSelField infield; + SqlSelField outField; + + // ʼṹ + infield.nCharNum = inputValueCount; + infield.nIntNum = 0; + outField.nCharNum = 0; + outField.nIntNum = 0; + + *outputColumn = 0; + *outputValueCount = 0; + + for (i = 0; i < inputValueCount; i++) + { + strcpy(infield.caCharValue[i], inputValue[i]); + } + + // ִвѯ + + + if (ret = _QuerySQL(SQL, &outField, &infield)) + { + printf("SQLѯʧ!\n"); + QuitFreeHandle(); + return -1; + } + + // ȡ + ret = OCIAttrGet(ociHandle->p_sql, (ub4)OCI_HTYPE_STMT, (dvoid*)outputColumn, (ub4*)0, (ub4)OCI_ATTR_PARAM_COUNT, ociHandle->p_err); + + // ȡһ,ȥ + ret = OCIStmtFetch2(ociHandle->p_sql, ociHandle->p_err, 1, OCI_FETCH_LAST, 0, OCI_DEFAULT); + // ȡ + ret = OCIAttrGet(ociHandle->p_sql, (ub4)OCI_HTYPE_STMT, (dvoid*)outputValueCount, (ub4*)0, (ub4)OCI_ATTR_ROW_COUNT, ociHandle->p_err); + + if (*outputValueCount == 0) + return 0; + + + // ʼڴ沢Ҵ洢 + ret = OCIStmtFetch2(ociHandle->p_sql, ociHandle->p_err, 1, OCI_FETCH_FIRST, 0, OCI_DEFAULT); + *outputValue = (char***)calloc((*outputValueCount) + 1, sizeof(char**)); + do + { + (*outputValue)[i] = (char**)calloc((*outputColumn) + 1, sizeof(char*)); + for (j = 0; j < (*outputColumn); j++) + { + (*outputValue)[i][j] = (char*)calloc(1000, sizeof(char)); + strcpy((*outputValue)[i][j], outField.caCharValue[j]); + //printf("outValue[%d][%d] = %s , ַ=%d, ַָ= %d\n ",i,j,(*outputValue)[i][j],&(*outputValue)[i][j],(*outputValue)[i][j]); + } + i++; + } while ((ret = OCIStmtFetch2(ociHandle->p_sql, ociHandle->p_err, 1, OCI_FETCH_NEXT, 1, OCI_DEFAULT) != OCI_NO_DATA)); + + return 0; +} + + +// IJѯ +int QuerySQLNoInputParam(char* SQL, int* outputColumn, int* outputValueCount, char**** outputValue) +{ + return QuerySQL(SQL, 0, NULL, outputColumn, outputValueCount, outputValue); +} + +// ޲ +int ExecuteSQLNoInputParam(char* SQL) +{ + return ExecuteSQL(SQL, 0, NULL); +} + +// Ͽ +void DisConnServer() +{ + if (ociHandle != NULL) + QuitFreeHandle(); +} + diff --git a/CONNOR_ITK/ocilib.h b/CONNOR_ITK/ocilib.h new file mode 100644 index 0000000..6275f54 --- /dev/null +++ b/CONNOR_ITK/ocilib.h @@ -0,0 +1,98 @@ +/*===================================================================================================================== + Copyright(c) 2012 ORIGIN. + Unpublished - All rights reserved +======================================================================================================================= +File description: + + Filename: ocilib.h + Module : OCI + + This Header file of OCI library Package. + +======================================================================================================================= +Date Name Description of Change +1-Feb-2015 Ray Initialize creation +$HISTORY$ +=====================================================================================================================*/ +#include +#include +#include +#include +#include +//#include + +#define OCI_FAIL 1 +#define OCI_OK 0 + +#ifdef __cplusplus +extern "C" +{ +#endif + /** + * ݿ. + * @param username - û + * @param password - + * @param dbname - ݿSID + * @return - OCI_OK or error code + * + * ORACLE ݿװ + */ + extern int ConnServer(char* username, char* password, char* dbname); + + + /** + * ִSQL. + * @param SQL - SQL + * @return - OCI_OK or error code + * + * ORACLE ݿװ + */ + extern int ExecuteSQLNoInputParam(char* SQL); + + /** + * ִSQL. + * @param SQL - SQL + * @param inputValueCount - + * @param inputValue - ֵ + * @return - OCI_OK or error code + * + * ORACLE ݿװ + */ + extern int ExecuteSQL(char* SQL, int inputValueCount, char** inputValue); + + /** + * IJѯSQL. + * @param SQL - SQL + * @param outputColumn - е + * @param outputValueCount - е + * @param outputValue - + * @return - OCI_OK or error code + * + * ORACLE ݿװ + */ + extern int QuerySQLNoInputParam(char* SQL, int* outputColumn, int* outputValueCount, char**** outputValue); + + /** + * IJѯSQL. + * @param SQL - SQL + * @param inputValueCount - + * @param inputValue - ֵ + * @param outputColumn - е + * @param outputValueCount - е + * @param outputValue - + * @return - OCI_OK or error code + * + * ORACLE ݿװ + */ + extern int QuerySQL(char* SQL, int inputValueCount, char** inputValue, int* outputColumn, int* outputValueCount, char**** outputValue); + + /** + * Ͽݿ. + * + * ORACLE ݿװ + */ + extern void DisConnServer(); + +#ifdef __cplusplus +} +#endif diff --git a/JL_ITK.sln b/JL_ITK.sln new file mode 100644 index 0000000..622bebe --- /dev/null +++ b/JL_ITK.sln @@ -0,0 +1,28 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio 14 +VisualStudioVersion = 14.0.25420.1 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "CONNOR_ITK", "CONNOR_ITK\CONNOR_ITK.vcxproj", "{A5936B6A-CCDE-41C6-A5EC-5D8CAF769F7F}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|x64 = Debug|x64 + Debug|x86 = Debug|x86 + Release|x64 = Release|x64 + Release|x86 = Release|x86 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {A5936B6A-CCDE-41C6-A5EC-5D8CAF769F7F}.Debug|x64.ActiveCfg = Debug|x64 + {A5936B6A-CCDE-41C6-A5EC-5D8CAF769F7F}.Debug|x64.Build.0 = Debug|x64 + {A5936B6A-CCDE-41C6-A5EC-5D8CAF769F7F}.Debug|x86.ActiveCfg = Debug|Win32 + {A5936B6A-CCDE-41C6-A5EC-5D8CAF769F7F}.Debug|x86.Build.0 = Debug|Win32 + {A5936B6A-CCDE-41C6-A5EC-5D8CAF769F7F}.Release|x64.ActiveCfg = Release|x64 + {A5936B6A-CCDE-41C6-A5EC-5D8CAF769F7F}.Release|x64.Build.0 = Release|x64 + {A5936B6A-CCDE-41C6-A5EC-5D8CAF769F7F}.Release|x86.ActiveCfg = Release|Win32 + {A5936B6A-CCDE-41C6-A5EC-5D8CAF769F7F}.Release|x86.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/OCI/include/nzerror.h b/OCI/include/nzerror.h new file mode 100644 index 0000000..2759aca --- /dev/null +++ b/OCI/include/nzerror.h @@ -0,0 +1,674 @@ +/* DISABLE check_long_lines */ + +/* + * $Header: security_src/public/nzerror.h /st_ldap_db11.2/1 2009/07/15 13:57:04 rchahal Exp $ + * + * Copyright (c) 1995, 2009, Oracle and/or its affiliates. + * All rights reserved. + */ + +/* ENABLE check_long_lines */ +/* + NAME + nzerror.h - error numbers for the Oracle Security Server + DESCRIPTION + None. + PUBLIC FUNCTION(S) + None. + PRIVATE FUNCTION(S) + None. + NOTES + A pragma is used to silence olint about the enum value names not being + unique within 7 characters. This limit is being changed to 30. + MODIFIED + rchahal 06/12/06 - + skalyana 01/30/05 - + rchahal 07/16/04 - add cert label + rchahal 07/06/04 - + rchahal 10/15/03 - bug 2513821 + rchahal 08/14/03 - new error range (43000 - 43499) + skalyana 08/25/03 - Error changes + rchahal 06/27/03 - RSA errors + rchahal 05/27/03 - convert wallet + skalyana 03/07/03 - Move FIPS errors + rchahal 02/28/03 - bug 2648177 + rchahal 01/20/03 - use sltsky + rchahal 11/11/02 - pkcs11 support + skalyana 11/29/02 - Add mutex errors + akoyfman 11/01/02 - adding crl cache + rchahal 10/23/02 - crldp error + rchahal 10/15/02 - fetch crl from ldap + rchahal 10/07/02 - crl support + akoyfman 10/16/02 - Update with SSL PLus 4.2 errors + skalyana 10/04/02 - Certicom SSL Plus 4.2 Upgrade changes + akoyfman 08/06/02 - adding sso wallet errors + akoyfman 07/12/02 - adding secret store errors + skalyana 07/07/02 - Add more errors for FIPS self tests + skalyana 07/01/02 - Add more errors + skalyana 06/03/02 - Add NZ error for self test failure. + ajacobs 02/22/01 - Add some entrust errors + vle 02/09/01 - add error mesg + lkethana 08/11/00 - Extension Errors + lkethana 07/30/00 - add pkcs12 errors + lkethana 06/17/00 - mult cert errors + lkethana 06/11/00 - multiple cert support + rturlapa 03/29/00 - Add error meesage for Entrust Login failure. + rwessman 07/07/99 - Deleted include of sslerrs.h. It caused the RDBMS bu + rwessman 07/02/99 - fixed merge errors + rwessman 07/01/99 - moved NZOS errors to nzerror to make them visible + supriya 12/16/98 - add new error for cert chain. + arswamin 12/04/98 - add NZERROR_NO_MATCHING_PRIVATE_KEY + qdinh 11/12/98 - add NZERROR_VALIDITY_EXPIRED. + arswamin 06/17/98 - add INIT_FAILED + sdange 06/10/98 - change wrong password to bad password + amthakur 06/09/98 - adding error messages + wliau 03/10/97 - Add new error message for snzdfo.c. + rwessman 03/14/97 - Consolidated PL/SQL toolkit errors into generic erro + rwessman 02/26/97 - Added NZERROR_UNSUPPORTED. Corrected values of + errors outside the valid range. + asriniva 03/02/97 - Fix olint warning + rwessman 02/26/97 - Added NZERROR_UNSUPPORTED + rwessman 01/02/97 - Changed PLSQL package errors to be TK_PLSQL to + separate them from the errors generated by the + Oracle interface. + rwessman 12/30/96 - Merged in PL/SQL toolkit errors + sdange 11/14/96 - (Added NZERROR_DECRYPT_FAILED to the enum list) + rwessman 12/02/96 - + rwessman 11/25/96 - Added error messages for PL/SQL functions. + asriniva 10/31/96 - Include oratypes.h + asriniva 10/29/96 - Fix numbering. + asriniva 10/29/96 - Fix error numbers + asriniva 10/29/96 - Correct type-o + asriniva 10/28/96 - Add more TK errors + asriniva 10/28/96 - Convert OKAPI errors to TK errors. + rwessman 10/17/96 - still more OSS TK errors + asriniva 10/16/96 - OKAPI errors + asriniva 10/15/96 - OSSTK errors + rwessman 10/15/96 - Added more OSS TK errors + asriniva 10/09/96 - Add OSSTK errors. + rwessman 09/05/96 - Added errors for PL/SQL functions. + wliau 09/05/96 - correct error numbers. + $Log: $ + * Revision 1.26 1996/07/15 23:07:23 wliau + * Added NZERROR_AUTH_SHARED_MEMORY + * + * Revision 1.25 1996/07/01 20:40:15 asriniva + * Finished RSA verify/sign. + * + * Revision 1.24 1996/06/27 20:39:41 rwessman + * Added more errors. + * + * Revision 1.23 1996/05/31 17:33:40 rwessman + * Updated nzerror.h to contain bug # for olint enum bug. + * + * Revision 1.22 1996/05/31 17:12:30 rwessman + * Assigned values to the various errors. + * + * Revision 1.21 1996/05/13 20:46:58 ggilchri + * Added more attribute related error conditions + * +*/ + +#ifndef NZERROR_ORACLE +# define NZERROR_ORACLE + +#ifndef ORATYPES +# include +#endif /* ORATYPES */ + +/* +** Errors - when an error is added here, a message corresponding to the +** error number must be added to the message file. +** New errors must be assigned numbers, otherwise the compiler can assign any +** value that it wants, which may lead to invalid error numbers being +** generated. +** The number range currently assigned to the OSS is 28750 - 29249 +** New number range 43000 - 43499 +*/ + +typedef enum nzerror +{ + NZERROR_OK = 0, + NZERROR_GENERIC = 28750, /* A catchall for errors */ + NZERROR_NO_MEMORY = 28751, /* No more memory */ + NZERROR_DATA_SOURCE_INIT_FAILED = 28752, /* Failed to init data source */ + NZERROR_DATA_SOURCE_TERM_FAILED = 28753,/* Failed to terminate data source */ + NZERROR_OBJECT_STORE_FAILED = 28754, /* Store object in data source failed */ + NZERROR_OBJECT_GET_FAILED = 28755, + /* Failed to obtain object from data source */ + NZERROR_MEMORY_ALLOC_FAILED = 28756, + /* Callback failed to allocate memory */ + NZERROR_MEMORY_ALLOC_0_BYTES = 28757, + /* Attempted to ask for 0 bytes of memory */ + NZERROR_MEMORY_FREE_FAILED = 28758, + /* Callback failed to free memory */ + NZERROR_FILE_OPEN_FAILED = 28759, + /* Open of file failed */ + NZERROR_LIST_CREATION_FAILED = 28760, + /* Creation of list failed */ + NZERROR_NO_ELEMENT = 28761, + /* No list element found */ + NZERROR_ELEMENT_ADD_FAILED = 28762, + /* Addition of list element failed */ + NZERROR_PARAMETER_BAD_TYPE = 28763, + /* Retrieval of an unknown parameter type */ + NZERROR_PARAMETER_RETRIEVAL = 28764, /* Retrieval of parameter failed */ + + NZERROR_NO_LIST = 28765, /* Data method list does not exist */ + NZERROR_TERMINATE_FAIL = 28766, /* Failed to terminate */ + NZERROR_BAD_VERSION_NUMBER = 28767, /* Bad version number */ + NZERROR_BAD_MAGIC_NUMBER = 28768, /* Bad magic number */ + NZERROR_METHOD_NOT_FOUND = 28769, + /* Data retrieval method specified does not exist */ + NZERROR_ALREADY_INITIALIZED = 28770, + /*The data source is already initialized */ + NZERROR_NOT_INITIALIZED = 28771, /* The data source is not initialized */ + NZERROR_BAD_FILE_ID = 28772, /* File ID is bad */ + NZERROR_WRITE_MAGIC_VERSION = 28773, /* Failed to write magic and version */ + NZERROR_FILE_WRITE_FAILED = 28774, /* Failed to write to file */ + NZERROR_FILE_CLOSE_FAILED = 28775, /* Failed to close file */ + NZERROR_OUTPUT_BUFFER_TOO_SMALL = 28776, + /* The buffer supplied by the caller is too small */ + NZERROR_BINDING_CREATION_FAILED = 28777,/* NL failed in creating a binding */ + NZERROR_PARAMETER_MALFORMED = 28778, /* A parameter was in a bad format */ + NZERROR_PARAMETER_NO_METHOD = 28779, + /* No method was specified for a data type */ + NZERROR_BAD_PARAMETER_METHOD = 28780, /* Illegal method for data type */ + NZERROR_PARAMETER_NO_DATA = 28781, /* No method specified when required */ + NZERROR_NOT_ALLOCATED = 28782, /* Data source is not allocated */ + NZERROR_INVALID_PARAMETER = 28783, /* Invalid parameter name */ + NZERROR_FILE_NAME_TRANSLATION = 28784,/* Could not translate OSD file name */ + NZERROR_NO_SUCH_PARAMETER = 28785, /* Selected parameter is non-existent */ + + NZERROR_DECRYPT_FAILED = 28786, + /* Encrypted private key decryption failure */ + NZERROR_ENCRYPT_FAILED = 28787, /* Private key encryption failed */ + + NZERROR_INVALID_INPUT = 28788, /* Incorrect input or unknown error */ + + NZERROR_NAME_TYPE_NOT_FOUND = 28789, + /* Type of name requested is not available */ + NZERROR_NLS_STRING_OPEN_FAILED = 28790, + /* Failure to generate an NLS string */ + NZERROR_CERTIFICATE_VERIFY = 28791, /* Failed to verify a certificate */ + NZERROR_OCI_PLSQL_FAILED = 28792, + /* an OCI call to process some plsql failed */ + NZERROR_OCI_BIND_FAILED = 28793, + /* an OCI call to bind an internal var. failed */ + NZERROR_ATTRIBUTE_INIT = 28794, /* failed to init role retrieval */ + NZERROR_ATTRIBUTE_FINISH_FAILED = 28795,/* Did not complete role retrieval */ + NZERROR_UNSUPPORTED_METHOD = 28796, /* Data method specified not supported */ + NZERROR_INVALID_KEY_DATA_TYPE = 28797, + /* Invalid data type specified for key */ + NZEROR_BIND_SUBKEY_COUNT = 28798, + /* Number of sub-keys to bind does not match count in initialized key */ + NZERROR_AUTH_SHARED_MEMORY = 28799, + /* Failed to retreieve authentication information from the shared memory */ + NZERROR_RIO_OPEN = 28800, /* RIO Open Failed */ + NZERROR_RIO_OBJECT_TYPE = 28801, /* RIO object type invalid */ + NZERROR_RIO_MODE = 28802, /* RIO mode invalid */ + NZERROR_RIO_IO = 28803, /* RIO io set or numberinvalid */ + NZERROR_RIO_CLOSE = 28804, /* RIO close failed */ + NZERROR_RIO_RETRIEVE = 28805, /* RIO retrieve failed */ + NZERROR_RIO_STORE = 28806, /* RIO store failed */ + NZERROR_RIO_UPDATE = 28807, /* RIO update failed */ + NZERROR_RIO_INFO = 28808, /* RIO info failed */ + NZERROR_RIO_DELETE = 28809, /* RIO delete failed */ + NZERROR_KD_CREATE = 28810, /* Key descriptor create failed */ + NZERROR_RIO_ACCESS_DESCRIPTOR = 28811, /* access descriptor invalid */ + NZERROR_RIO_RECORD = 28812, /* record invalid */ + NZERROR_RIO_RECORD_TYPE = 28813, /* record type and AD type not matched */ + NZERROR_PLSQL_ORACLE_TO_REAL = 28814, + /* A number passed to PL/SQL could not be converted to real format */ + NZERROR_PLSQL_REAL_TO_ORACLE = 28815, + /* A number in machine format could not be converted to Oracle format */ + NZERROR_TK_PLSQL_NO_PASSWORD = 28816, + /* A password was not provided to a PL/SQL function */ + NZERROR_TK_PLSQL_GENERIC = 28817, + /* A PL/SQL function returned an error */ + NZERROR_TK_PLSQL_NO_CONTEXT = 28818, + /* The package context was not specified to a PL/SQL function */ + NZERROR_TK_PLSQL_NO_DIST_NAME = 28819, + /* The user's distinguished name was not provided to a PL/SQL function */ + NZERROR_TK_PLSQL_NO_STATE = 28820, +/* The state of either a signature or decryption/encryption was not provided */ + NZERROR_TK_PLSQL_NO_INPUT = 28821, + /* An input buffer was specified to a PL/SQL function */ + NZERROR_TK_PLSQL_NO_SEED = 28822, + /* No seed was specified to the PL/SQL seed initialization function */ + NZERROR_TK_PLSQL_NO_BYTES = 28823, + /* Number of bytes was not specified to the PL/SQL random number generator */ + NZERROR_TK_INVALID_STATE = 28824, + /* Invalid encryption/decryption/signature state passed */ + NZERROR_TK_PLSQL_NO_ENG_FUNC = 28825, + /* No crypto engine function was passed in */ + NZERROR_TK_INV_ENG_FUNC = 28826, + /* An invalid crypto engine function was passed in */ + NZERROR_TK_INV_CIPHR_TYPE = 28827, + /* An invalid cipher type was passed in */ + NZERROR_TK_INV_IDENT_TYPE = 28828, + /* An invalid identity type was specified */ + NZERROR_TK_PLSQL_NO_CIPHER_TYPE = 28829, + /* No cipher type was specified */ + NZERROR_TK_PLSQL_NO_IDENT_TYPE = 28830, + /* No identity type was specified */ + NZERROR_TK_PLSQL_NO_DATA_FMT = 28831, + /* No data unit format was specified */ + NZERROR_TK_INV_DATA_FMT = 28832, + /* Invalid data unit format was provided to function */ + NZERROR_TK_PLSQL_INSUFF_INFO = 28833, + /* Not enough info (usually parameters) provided to a PL/SQL function */ + NZERROR_TK_PLSQL_BUF_TOO_SMALL = 28834, + /* Buffer provided by PL/SQL is too small for data to be returned */ + NZERROR_TK_PLSQL_INV_IDENT_DESC = 28835, + /* Identity descriptor not present or too small */ + NZERROR_TK_PLSQL_WALLET_NOTOPEN = 28836, + /* Wallet has not been opened yet */ + NZERROR_TK_PLSQL_NO_WALLET = 28837, + /* No wallet descriptor specified to PL/SQL function */ + NZERROR_TK_PLSQL_NO_IDENTITY = 28838, + /* No identity descriptor specified to PL/SQL function */ + NZERROR_TK_PLSQL_NO_PERSONA = 28839, + /* No persona descriptor was specified to PL/SQL function */ + NZERROR_TK_PLSQL_WALLET_OPEN = 28840, + /* Wallet was already opened */ + NZERROR_UNSUPPORTED = 28841, /* Operation is not supported */ + NZERROR_FILE_BAD_PERMISSION = 28842, /* Bad file permission specified */ + NZERROR_FILE_OSD_ERROR = 28843, /* OSD error when opening file */ + NZERROR_NO_WALLET = 28844, /* cert + privkey + tp files do not exist */ + NZERROR_NO_CERTIFICATE_ALERT = 28845, /* no certificate */ + NZERROR_NO_PRIVATE_KEY = 28846, /* no private-key */ + NZERROR_NO_CLEAR_PRIVATE_KEY_FILE = 28847, /* no clear key-file */ + NZERROR_NO_ENCRYPTED_PRIVATE_KEY_FILE = 28848, /* no encrypted priv key */ + NZERROR_NO_TRUSTPOINTS = 28849, /* no trustpoints */ + NZERROR_NO_CLEAR_TRUSTPOINT_FILE = 28850, /* no clear trustpoints */ + NZERROR_NO_ENCRYPTED_TRUSTPOINT_FILE = 28851, /* no encrypted trustpoints */ + NZERROR_BAD_PASSWORD = 28852, /* bad password */ + NZERROR_INITIALIZATION_FAILED = 28853, /* init failed or + module loading failed */ + /******************************* SSL ERRORS ********************************/ + /* + * In order to allow SSL errors to be mapped to Oracle errors, space is + * provided here. One Oracle error is provided for each SSL error to make + * error handling easier. A macro is provided to do the conversion. + * NOTE: ANY CHANGE IN SSL ERRORS MUST BE REFLECTED HERE. + * To add an SSL error, use the following formula to calculate the Oracle + * error: + * new_oracle_error = (new_ssl_error - SSLMemoryError) + NZERROR_SSLMemoryErr + * or numerically: + * new_oracle_error = (new_ssl_error - -7000) + 28854 + */ + NZERROR_SSLMemoryErr = 28854, + NZERROR_SSLUnsupportedErr = 28855, + NZERROR_SSLOverflowErr = 28856, + NZERROR_SSLUnknownErr = 28857, + NZERROR_SSLProtocolErr = 28858, + NZERROR_SSLNegotiationErr = 28859, + NZERROR_SSLFatalAlert = 28860, + NZERROR_SSLWouldBlockErr = 28861, + NZERROR_SSLIOErr = 28862, + NZERROR_SSLSessionNotFoundErr = 28863, + NZERROR_SSLConnectionClosedGraceful = 28864, + NZERROR_SSLConnectionClosedError = 28865, + NZERROR_ASNBadEncodingErr = 28866, + NZERROR_ASNIntegerTooBigErr = 28867, + NZERROR_X509CertChainInvalidErr = 28868, + NZERROR_X509CertExpiredErr = 28869, + NZERROR_X509NamesNotEqualErr = 28870, + NZERROR_X509CertChainIncompleteErr = 28871, + NZERROR_X509DataNotFoundErr = 28872, + NZERROR_SSLBadParameterErr = 28873, + NZERROR_SSLIOClosedOverrideGoodbyeKiss = 28874, + NZERROR_X509MozillaSGCErr = 28875, + NZERROR_X509IESGCErr = 28876, + NZERROR_ImproperServerCredentials = 28877, + NZERROR_ImproperClientCredentials = 28878, + NZERROR_NoProtocolSideSet = 28879, + NZERROR_setPersonaFailed = 28880, + NZERROR_setCertFailed = 28881, + NZERROR_setVKeyFailed = 28882, + NZERROR_setTPFailed = 28883, + NZERROR_BadCipherSuite = 28884, + NZERROR_NoKeyPairForKeyUsage = 28885, + +/* ============>>> ENTRUST ERRORS */ + NZERROR_EntrustLoginFailed = 28890, + NZERROR_EntrustGetInfoFailed = 28891, + NZERROR_EntrustLoadCertificateFailed = 28892, + NZERROR_EntrustGetNameFailed = 28893, + +/* ============>>> NZERRORS CONTINUED */ + NZERROR_CertNotInstalled = 29000, + NZERROR_ServerDNMisMatched = 29002, + NZERROR_ServerDNMisConfigured = 29003, + +/* ============>>> PKI VENDORS ERRORS 29050 - 29099 */ + +/* ============>>> SSL Errors CONTINUED */ + NZERROR_CIC_ERR_SSL_ALERT_CB_FAILURE = 29004, + NZERROR_CIC_ERR_SSL_BAD_CERTIFICATE = 29005, + NZERROR_CIC_ERR_SSL_BAD_CERTIFICATE_REQUEST = 29006, + NZERROR_CIC_ERR_SSL_BAD_CLEAR_KEY_LEN = 29007, + NZERROR_CIC_ERR_SSL_BAD_DHPARAM_KEY_LENGTH = 29008, + NZERROR_CIC_ERR_SSL_BAD_ENCRYPTED_KEY_LEN = 29009, + NZERROR_CIC_ERR_SSL_BAD_EXPORT_KEY_LENGTH = 29010, + NZERROR_CIC_ERR_SSL_BAD_FINISHED_MESSAGE = 29011, + NZERROR_CIC_ERR_SSL_BAD_KEY_ARG_LEN = 29012, + NZERROR_CIC_ERR_SSL_BAD_MAC = 29013, + NZERROR_CIC_ERR_SSL_BAD_MAX_FRAGMENT_LENGTH_EXTENSION = 29014, + NZERROR_CIC_ERR_SSL_BAD_MESSAGE_LENGTH = 29015, + NZERROR_CIC_ERR_SSL_BAD_PKCS1_PADDING = 29016, + NZERROR_CIC_ERR_SSL_BAD_PREMASTER_SECRET_LENGTH = 29017, + NZERROR_CIC_ERR_SSL_BAD_PREMASTER_SECRET_VERSION = 29018, + NZERROR_CIC_ERR_SSL_BAD_PROTOCOL_VERSION = 29019, + NZERROR_CIC_ERR_SSL_BAD_RECORD_LENGTH = 29020, + NZERROR_CIC_ERR_SSL_BAD_SECRET_KEY_LEN = 29021, + NZERROR_CIC_ERR_SSL_BAD_SIDE = 29022, + NZERROR_CIC_ERR_SSL_BUFFERS_NOT_EMPTY = 29023, + NZERROR_CIC_ERR_SSL_CERTIFICATE_VALIDATE_FAILED = 29024, + NZERROR_CIC_ERR_SSL_CERT_CHECK_CALLBACK = 29025, + NZERROR_CIC_ERR_SSL_DECRYPT_FAILED = 29026, + NZERROR_CIC_ERR_SSL_ENTROPY_COLLECTION = 29027, + NZERROR_CIC_ERR_SSL_FAIL_SERVER_VERIFY = 29028, + NZERROR_CIC_ERR_SSL_HANDSHAKE_ALREADY_COMPLETED = 29029, + NZERROR_CIC_ERR_SSL_HANDSHAKE_REQUESTED = 29030, + NZERROR_CIC_ERR_SSL_HANDSHAKE_REQUIRED = 29031, + NZERROR_CIC_ERR_SSL_INCOMPLETE_IDENTITY = 29032, + NZERROR_CIC_ERR_SSL_INVALID_PFX = 29033, + NZERROR_CIC_ERR_SSL_NEEDS_CIPHER_OR_CLIENTAUTH = 29034, + NZERROR_CIC_ERR_SSL_NEEDS_PRNG = 29035, + NZERROR_CIC_ERR_SSL_NOT_SUPPORTED = 29036, + NZERROR_CIC_ERR_SSL_NO_CERTIFICATE = 29037, + NZERROR_CIC_ERR_SSL_NO_MATCHING_CERTIFICATES = 29038, + NZERROR_CIC_ERR_SSL_NO_MATCHING_CIPHER_SUITES = 29039, + NZERROR_CIC_ERR_SSL_NO_SUPPORTED_CIPHER_SUITES = 29040, + NZERROR_CIC_ERR_SSL_NULL_CB = 29041, + NZERROR_CIC_ERR_SSL_READ_BUFFER_NOT_EMPTY = 29042, + NZERROR_CIC_ERR_SSL_READ_REQUIRED = 29043, + NZERROR_CIC_ERR_SSL_RENEGOTIATION_ALREADY_REQUESTED = 29044, + NZERROR_CIC_ERR_SSL_RENEGOTIATION_REFUSED = 29045, + NZERROR_CIC_ERR_SSL_RESUMABLE_SESSION = 29046, + NZERROR_CIC_ERR_SSL_TLS_EXTENSION_MISMATCH = 29047, + NZERROR_CIC_ERR_SSL_UNEXPECTED_MSG = 29048, + NZERROR_CIC_ERR_SSL_UNKNOWN_RECORD = 29049, + NZERROR_CIC_ERR_SSL_UNSUPPORTED_CLIENT_AUTH_MODE = 29050, + NZERROR_CIC_ERR_SSL_UNSUPPORTED_PUBKEY_TYPE = 29051, + NZERROR_CIC_ERR_SSL_WRITE_BUFFER_NOT_EMPTY = 29052, + NZERROR_CIC_ERR_PKCS12_MISSING_ALG = 29053, + NZERROR_CIC_ERR_PKCS_AUTH_FAILED = 29054, + NZERROR_CIC_ERR_PKCS_BAD_CONTENT_TYPE = 29055, + NZERROR_CIC_ERR_PKCS_BAD_INPUT = 29056, + NZERROR_CIC_ERR_PKCS_BAD_PADDING = 29057, + NZERROR_CIC_ERR_PKCS_BAD_SN = 29058, + NZERROR_CIC_ERR_PKCS_BAD_SN_LENGTH = 29059, + NZERROR_CIC_ERR_PKCS_BAD_VERSION = 29060, + NZERROR_CIC_ERR_PKCS_BASE = 29061, + NZERROR_CIC_ERR_PKCS_FIELD_NOT_PRESENT = 29062, + NZERROR_CIC_ERR_PKCS_NEED_CERTVAL = 29063, + NZERROR_CIC_ERR_PKCS_NEED_PASSWORD = 29064, + NZERROR_CIC_ERR_PKCS_NEED_PKC = 29065, + NZERROR_CIC_ERR_PKCS_NEED_PRV_KEY = 29066, + NZERROR_CIC_ERR_PKCS_NEED_TRUSTED = 29067, + NZERROR_CIC_ERR_PKCS_UNSUPPORTED_CERT_FORMAT = 29068, + NZERROR_CIC_ERR_PKCS_UNSUP_PRVKEY_TYPE = 29069, + NZERROR_CIC_ERR_CODING_BAD_PEM = 29070, + NZERROR_CIC_ERR_CODING_BASE = 29071, + NZERROR_CIC_ERR_DER_BAD_ENCODING = 29072, + NZERROR_CIC_ERR_DER_BAD_ENCODING_LENGTH = 29073, + NZERROR_CIC_ERR_DER_BASE = 29074, + NZERROR_CIC_ERR_DER_ELEMENT_TOO_LONG = 29075, + NZERROR_CIC_ERR_DER_INDEFINITE_LENGTH = 29076, + NZERROR_CIC_ERR_DER_NO_MORE_ELEMENTS = 29077, + NZERROR_CIC_ERR_DER_OBJECT_TOO_LONG = 29078, + NZERROR_CIC_ERR_DER_TAG_SIZE = 29079, + NZERROR_CIC_ERR_DER_TIME_OUT_OF_RANGE = 29080, + NZERROR_CIC_ERR_DER_UNUSED_BITS_IN_BIT_STR = 29081, + NZERROR_CIC_ERR_GENERAL_BASE = 29082, + NZERROR_CIC_ERR_HASH_BASE = 29083, + NZERROR_CIC_ERR_ILLEGAL_PARAM = 29084, + NZERROR_CIC_ERR_MEM_NOT_OURS = 29085, + NZERROR_CIC_ERR_MEM_OVERRUN = 29086, + NZERROR_CIC_ERR_MEM_UNDERRUN = 29087, + NZERROR_CIC_ERR_MEM_WAS_FREED = 29088, + NZERROR_CIC_ERR_NOT_FOUND = 29090, + NZERROR_CIC_ERR_NO_PTR = 29091, + NZERROR_CIC_ERR_TIMEOUT = 29092, + NZERROR_CIC_ERR_UNIT_MASK = 29093, + NZERROR_CIC_ERR_BAD_CTX = 29094, + NZERROR_CIC_ERR_BAD_INDEX = 29095, + NZERROR_CIC_ERR_BAD_LENGTH = 29096, + NZERROR_CIC_ERR_CODING_BAD_ENCODING = 29097, + NZERROR_CIC_ERR_SSL_NO_CLIENT_AUTH_MODES = 29098, + + /* ============>>> PKCS12 error 29100 - 29149 */ + + NZERROR_LOCKEYID_CREATE_FAILED = 29100, + NZERROR_P12_ADD_PVTKEY_FAILED = 29101, + NZERROR_P12_ADD_CERT_FAILED = 29102, + NZERROR_P12_WLT_CREATE_FAILED = 29103, + NZERROR_P12_ADD_CERTREQ_FAILED = 29104, + NZERROR_P12_WLT_EXP_FAILED = 29105, + NZERROR_P12_WLT_IMP_FAILED = 29106, + NZERROR_P12_CREATE_FAILED = 29107, + NZERROR_P12_DEST_FAILED = 29107, + NZERROR_P12_RAND_ERROR = 29108, + NZERROR_P12_PVTKEY_CRT_FAILED = 29109, + NZERROR_P12_INVALID_BAG = 29110, + NZERROR_P12_INVALID_INDEX = 29111, + NZERROR_P12_GET_CERT_FAILED = 29112, + NZERROR_P12_GET_PVTKEY_FAILED = 29113, + NZERROR_P12_IMP_PVTKEY_FAILED = 29114, + NZERROR_P12_EXP_PVTKEY_FAILED = 29115, + NZERROR_P12_GET_ATTRIB_FAILED = 29116, + NZERROR_P12_ADD_ATTRIB_FAILED = 29117, + NZERROR_P12_CRT_ATTRIB_FAILED = 29118, + NZERROR_P12_IMP_CERT_FAILED = 29119, + NZERROR_P12_EXP_CERT_FAILED = 29120, + NZERROR_P12_ADD_SECRET_FAILED = 29121, + NZERROR_P12_ADD_PKCS11INFO_FAILED = 29122, + NZERROR_P12_GET_PKCS11INFO_FAILED = 29123, + NZERROR_P12_MULTIPLE_PKCS11_LIBNAME = 29124, + NZERROR_P12_MULTIPLE_PKCS11_TOKENLABEL = 29125, + NZERROR_P12_MULTIPLE_PKCS11_TOKENPASSPHRASE = 29126, + NZERROR_P12_UNKNOWN_PKCS11INFO = 29127, + NZERROR_P12_PKCS11_LIBNAME_NOT_SET = 29128, + NZERROR_P12_PKCS11_TOKENLABEL_NOT_SET = 29129, + NZERROR_P12_PKCS11_TOKENPASSPHRASE_NOT_SET = 29130, + NZERROR_P12_MULTIPLE_PKCS11_CERTLABEL = 29131, + +/* ===========>>> SSL Errors CONTINUED 29135 - 29139 */ + NZERROR_CIC_ERR_RANDOM = 29135, + NZERROR_CIC_ERR_SMALL_BUFFER = 29136, + NZERROR_CIC_ERR_SSL_BAD_CONTEXT = 29137, + +/* ==========>>> Mutex Errors 29138 - 29139 */ + NZERROR_MUTEX_INITIALIZE_FAILED = 29138, + NZERROR_MUTEX_DESTROY_FAILED = 29139, + + +/* ============>>> EXTENSIONS Errors 29140 - 29149 */ + NZERROR_BS_CERTOBJ_CREAT_FAILED = 29140, + NZERROR_BS_DER_IMP_FAILED = 29141, + + +/* ============>>> FIPS ERRORS 29150 - 29175 */ + NZERROR_DES_SELF_TEST_FAILED = 29150, + NZERROR_3DES_SELF_TEST_FAILED = 29151, + NZERROR_SHA_SELF_TEST_FAILED = 29152, + NZERROR_RSA_SELF_TEST_FAILED = 29153, + NZERROR_DRNG_SELF_TEST_FAILED = 29154, + NZERROR_CKEYPAIR_SELF_TEST_FAILED = 29155, + NZERROR_CRNG_SELF_TEST_FAILED = 29156, + NZERROR_FIPS_PATHNAME_ERROR = 29157, + NZERROR_FIPS_LIB_OPEN_FAILED = 29158, + NZERROR_FIPS_LIB_READ_ERROR = 29159, + NZERROR_FIPS_LIB_DIFFERS = 29160, + NZERROR_DAC_SELF_TEST_FAILED = 29161, + NZERROR_NONFIPS_CIPHERSUITE = 29162, + NZERROR_VENDOR_NOT_SUPPORTED_FIPS_MODE = 29163, + NZERROR_EXTERNAL_PKCS12_NOT_SUPPORTED_FIPS_MODE = 29164, + NZERROR_AES_SELF_TEST_FAILED = 29165, + +/* ============>>> CRL ERRORS 29176 - 29200 */ + NZERROR_CRL_SIG_VERIFY_FAILED = 29176, /*CRL signature verification failed*/ + NZERROR_CERT_NOT_IN_CRL = 29177, + /*Cert is not in CRL - cert is not revoked*/ + NZERROR_CERT_IN_CRL = 29178, /*Cert is in CRL - cert is revoked*/ + NZERROR_CERT_IN_CRL_CHECK_FAILED = 29179, /*Cert revocation check failed */ + NZERROR_INVALID_CERT_STATUS_PROTOCOL = 29180, + NZERROR_LDAP_OPEN_FAILED = 29181, /* ldap_open failed */ + NZERROR_LDAP_BIND_FAILED = 29182, /* ldap_bind failed */ + NZERROR_LDAP_SEARCH_FAILED = 29183, /* ldap_search failed */ + NZERROR_LDAP_RESULT_FAILED = 29184, /* ldap_result failed */ + NZERROR_LDAP_FIRSTATTR_FAILED = 29185, /* ldap_first_attribute failed */ + NZERROR_LDAP_GETVALUESLEN_FAILED = 29186, /* ldap_get_values_len failed */ + NZERROR_LDAP_UNSUPPORTED_VALMEC = 29187, + /* unsupported validation mechanism */ + NZERROR_LDAP_COUNT_ENTRIES_FAILED = 29188,/* ldap_count_entries failed */ + NZERROR_LDAP_NO_ENTRY_FOUND = 29189, /* No entry found in OID */ + NZERROR_LDAP_MULTIPLE_ENTRIES_FOUND = 29190, /* Multiple entries in OID*/ + NZERROR_OID_INFO_NOT_SET = 29191, + NZERROR_LDAP_VALMEC_NOT_SET = 29192, + /* Validation mechanism not set in OID*/ + NZERROR_CRLDP_NO_CRL_FOUND = 29193, + /* No CRL found using CRLDP mechanism */ + NZERROR_CRL_NOT_IN_CACHE = 29194, /* No CRL found in the cache*/ + NZERROR_CRL_EXPIRED = 29195, /* CRL nextUpdate time is in the past */ + +/* ============>>> ADD ERRORS HERE -- NOTE DECREASING numbers */ + NZERROR_DN_MATCH = 29222, /* for nztCompareDN */ + NZERROR_CERT_CHAIN_CREATION = 29223, /* unable to create a cert chain + * with the existing TPs for the + * cert to be installed. + */ + NZERROR_NO_MATCHING_CERT_REQ = 29224, /* No matching cert_req was + * found the corresponding to + * the privatekey which + * matches the cert to be + * installed */ + NZERROR_CERT_ALREADY_INSTALLED = 29225, /* we are attempting to + * install a cert again into + * a persona which already + * has it installed. + */ + NZERROR_NO_MATCHING_PRIVATE_KEY = 29226, /* could not find a matching + * persona-private(privatekey) in + * the Persona, for the given + * cert(public key). + */ + NZERROR_VALIDITY_EXPIRED = 29227, /* certificate validity date expired */ + NZERROR_TK_BYTES_NEEDED = 29228, /* Couldn't determine # of bytes needed */ + NZERROR_TK_BAD_MAGIC_NUMBER = 29229, + /* Magic number found in header does not match expected */ + NZERROR_TK_BAD_HEADER_LENGTH = 29230, + /* Header length passed in not sufficient for message header */ + NZERROR_TK_CE_INIT = 29231, /* Crypto engine failed to initialize */ + NZERROR_TK_CE_KEYINIT = 29232, /* Crypto engine key initialization failed */ + NZERROR_TK_CE_ENCODE_KEY = 29233, /* Count not encode key object */ + NZERROR_TK_CE_DECODE_KEY = 29234, /* Could not decode key into object */ + NZERROR_TK_CE_GEYKEYINFO = 29235, /* Crypto engine failed to get key info */ + NZERROR_TK_SEED_RANDOM = 29236, /* Couldn't seed random number generator */ + NZERROR_TK_CE_ALGFINISH = 29237, /* Couldn't finish algorithm */ + NZERROR_TK_CE_ALGAPPLY = 29238, /* Couldn't apply algorithm to data */ + NZERROR_TK_CE_ALGINIT = 29239, /* Couldn't init CE for algorithm */ + NZERROR_TK_ALGORITHM = 29240, /* Have no idea what algorithm you want */ + NZERROR_TK_CANNOT_GROW = 29241, /* Cannot grow output buffer block */ + NZERROR_TK_KEYSIZE = 29242, /* Key not large enough for data */ + NZERROR_TK_KEYTYPE = 29243, /* Unknown key type. */ + + NZERROR_TK_PLSQL_NO_WRL = 29244, + /* Wallet resource locator not specified to PL/SQL function */ + + NZERROR_TK_CE_FUNC = 29245, /* Unknown crypto engine function */ + NZERROR_TK_TDU_FORMAT = 29246, /* Unknown TDU format */ + NZERROR_TK_NOTOPEN = 29247, /* Object must be open */ + NZERROR_TK_WRLTYPE = 29248, /* Bad WRL type */ + NZERROR_TK_CE_STATE = 29249, /* Bad state specified for the crypto engine */ + + /* After 29249, use error numbers in block 43000 - 43499 */ + NZERROR_PKCS11_LIBRARY_NOT_FOUND = 43000, /* PKCS #11 library not found */ + NZERROR_PKCS11_TOKEN_NOT_FOUND = 43001, + /* can't find token with given label*/ + NZERROR_PKCS11_BAD_PASSPHRASE = 43002, /* passphrase is incorrect/expired */ + NZERROR_PKCS11_GET_FUNC_LIST = 43003, /* C_GetFunctionList returned error */ + NZERROR_PKCS11_INITIALIZE = 43004, /* C_Initialize returned error */ + NZERROR_PKCS11_NO_TOKENS_PRESENT = 43005, /* No tokens present */ + NZERROR_PKCS11_GET_SLOT_LIST = 43006, /* C_GetSlotList returned error */ + + NZERROR_PKCS11_GET_TOKEN_INFO = 43008, /* C_GetTokenInfo returned error */ + NZERROR_PKCS11_SYMBOL_NOT_FOUND = 43009, /* Symbol not found in PKCS11 lib */ + + NZERROR_PKCS11_TOKEN_LOGIN_FAILED = 43011, /* Token login failed */ + + NZERROR_PKCS11_CHANGE_PROVIDERS_ERROR = 43013, /* Change providers error */ + NZERROR_PKCS11_GET_PRIVATE_KEY_ERROR = 43014, + /* Error trying to find private key on token */ + NZERROR_PKCS11_CREATE_KEYPAIR_ERROR = 43015, /* Key pair gen error */ + NZERROR_PKCS11_WALLET_CONTAINS_P11_INFO = 43016, /* Wallet already contains + pkcs11 info */ + NZERROR_PKCS11_NO_CERT_ON_TOKEN = 43017, /* No cert found on token */ + NZERROR_PKCS11_NO_USER_CERT_ON_TOKEN = 43018, /*No user cert found on token*/ + NZERROR_PKCS11_NO_CERT_ON_TOKEN_WITH_GIVEN_LABEL = 43019, /*No cert found on token with given certificate label.*/ + NZERROR_PKCS11_MULTIPLE_CERTS_ON_TOKEN_WITH_GIVEN_LABEL = 43020, /*Multiple certs found on token with given certificate label.*/ + NZERROR_PKCS11_CERT_WITH_LABEL_NOT_USER_CERT = 43021, /*Cert with given cert is not a user cert because no corresponding pvt key found on token */ + + /* RSA ERRORS 43050 - 43059 */ + NZERROR_BIND_SERVICE_ERROR = 43050, /* C_BindService returned error */ + NZERROR_CREATE_KEY_OBJ_ERROR = 43051, /* B_CreateKeyObject returned error */ + NZERROR_GET_CERT_FIELDS = 43052, /* C_GetCertFields returned error */ + NZERROR_CREATE_PKCS10_OBJECT = 43053, + /* C_CreatePKCS10Object returned error */ + NZERROR_SET_PKCS10_FIELDS = 43054, /* C_SetPKCS10Fields returned error */ + NZERROR_SIGN_CERT_REQUEST = 43055, /* C_SignCertRequest returned error */ + NZERROR_GET_PKCS10_DER = 43056, /* C_GetPKCS10DER returned error */ + NZERROR_INITIALIZE_CERTC = 43057, /* C_InitializeCertC returned error */ + NZERROR_INSERT_PRIVATE_KEY = 43058, /* C_InsertPrivateKey returned error */ + NZERROR_RSA_ERROR = 43059, /* RSA error. See trace output */ + + /* slts ERRORS 43060 - 43069 */ + NZERROR_SLTSCTX_INIT_FAILED = 43060, /* sltsini() returned error */ + NZERROR_SLTSKYC_FAILED = 43061, /* sltskyc() returned error */ + NZERROR_SLTSCTX_TERM_FAILED = 43062, /* sltster() returned error */ + NZERROR_SLTSKYS_FAILED = 43063, /* sltskys() returned error */ + + NZERROR_INVALID_HEADER_LENGTH = 43070, /* bad sso header length */ + NZERROR_WALLET_CONTAINS_USER_CREDENTIALS = 43071, /* wallet not empty */ + NZERROR_CANNOT_MODIFY_AL = 43072, /* Cannot modify AL wallet */ + NZERROR_FILE_LOCK_FAILED = 43073, /* Cannot lock wallet file */ + + NZERROR_CSF_ALIAS_INVALID = 43100, /* alias is invalid */ + NZERROR_CSF_KEY_INVALID = 43101, /* key invalid */ + NZERROR_CSF_CRED_NOT_SUPPORTED = 43102, /* only pwd cred supported */ + NZERROR_CSF_HOSTNAME = 43103, /* hostname error */ + NZERROR_CSF_XML = 43104, /* XmlCreate error. See trace */ + NZERROR_CSF_WALLET_NOT_SPECIFIED = 43105, /* no wallet specified */ + NZERROR_CSF_MAP_NOT_IN_STORE = 43106, /* map does not exist in store */ + NZERROR_CSF_KEY_NOT_IN_STORE = 43107, /* key does not exist in store */ + NZERROR_CSF_ENTRY_EXISTS = 43108, /* entry with map/key exists */ + + NZERROR_LX_ERROR = 43120, /* lx api returned error */ + + NZERROR_LAST_ERROR = 43499, /* Last available error */ + /* MAXIMUM ERROR NUMBER IS 43499 */ + + /* + * DO NOT JUST INSERT NEW ERRORS IN ANY OLD PLACE. New errors should be + * added such the current error retains their integer values. Duplicate + * values will cause compiler errors. + */ + NZERROR_THIS_MUST_BE_LAST + +} nzerror; + +/* + * Macro to convert SSL errors to Oracle errors. As SSL errors are negative + * and Oracle numbers are positive, the following needs to be done. + * 1. The base error number, which is the highest, is added to the + * SSL error to get the index into the number range. + * 2. The result is added to the base Oracle number to get the Oracle error. + */ +#define NZERROR_SSL_TO_ORACLE(ssl_error_) \ + ((ssl_error_ == SSLNoErr) \ + ? NZERROR_OK \ + : (nzerror) ((ssl_error_ - SSLMemoryErr) + (uword) NZERROR_SSLMemoryErr)) +#endif /* NZERROR_ORACLE */ diff --git a/OCI/include/nzt.h b/OCI/include/nzt.h new file mode 100644 index 0000000..42fec33 --- /dev/null +++ b/OCI/include/nzt.h @@ -0,0 +1,2387 @@ +/* DISABLE check_long_lines */ + +/* Copyright (c) 1996, 2007, Oracle. All rights reserved. */ +/* Copyright (c) 1996, 2007, Oracle. All rights reserved. */ + +/* + * + */ + +/* + * NAME + * nzt.h + * + * DESCRIPTION + * Toolkit public declarations. + * + * PUBLIC FUNCTIONS + * nztwOpenWallet - Open a wallet based on a WRL and pwd. + * nztwCloseWallet - Close a wallet. + * + nztwCreateWallet - Create a new wallet. + * + nztwDestroyWallet - Destroy an existing wallet. + * nztwRetrievePersonaCopy - Retieve a copy of a particular persona. + * + nzteStorePersona - Store a persona in the wallet. + * nzteOpenPersona - Open a persona. + * nzteClosePersona - Close a persona. + * + nzteRemovePersona - Remove a persona from a wallet. + * + nzteCreatePersona - Create a persona. + * nzteDestroyPersona - Destroy a persona. + * nztiStoreTrustedIdentity - Store an identity with associated trust. + * nzteRetrieveTrustedIdentCopy - Retrieves a trusted identity from persona + * + nzteSetProtection - Modify the protection set in a persona. + * + nzteGetProtection - Get the protection set in a persona + * nztePriKey - Get the Private Key (X509 Only) + * nzteMyCert - Get the Certificate (X509 only) + * nzteX509CreatePersona - Create a persona given an X509 Certificate. + * + nztiRemoveIdentity - Remove an identity from a persona. + * nztiCreateIdentity - Create an identity. + * nztiDuplicateIdentity - Create a complete copy of an identity. + * nztiAbortIdentity - Discard an unstored identity. + * nztidGetIdentityDesc - Gets Identity Description from Identity. + * nztidFreeIdentityDesc - Frees memory for Identity Desc object. + * nztSign - Generate an attached signature. + * + nztxSignExpansion - Determine size of signature. + * nztVerify - Verify an attached signature. + * nztValidate - Validate an identity. + * nztsd_SignDetached - Generate a detached signature. + * + nztxsd_SignDetachedExpansion - Determine size of detached signature. + * nztved_VerifyDetached - Verify a detached signature. + * + nztEncrypt - Symmetric key encryption. + * + nztxEncryptExpansion - Determine the tdu length for encryption. + * + nztDecrypt - Symmetric key decryption. + * + nztEnvelope - Sign then encrypt data for recipient(s). + * + nztDeEnvelope - Reverse nztEnvelope. + * + nztKeyedHash - Generate keyed hash. + * + nztxKeyedHashExpansion - Determine size of TDU for keyed hash. + * nztHash - Generate hash. + * + nztxHashExpansion - Determine the size of the TDU for a hash. + * nztSeedRandom - See the random number generator. + * nztrb_RandomBytes - Generate a series of random bytes. + * nztrn_RandomNumber - Generate a random number. + * nztbbInitBlock - Initialize a buffer block. + * nztbbReuseBlock - Reuse a buffer block. + * nztbbSizeBlock - Find the size of the buffer block. + * nztbbGrowBlock - Grow initialized buffer block by 'inc' bytes. + * nztbbPurgeBlock - Purge the memory used within a buffer block. + * nztbbSetBlock - Set block to known state. + * nztkec_PKEncrypt - Encrypt data then encrypt key for recipient. + * nztkdc_PKDecrypt - Decrypt PKEncrypt'ed data. + * nztific_FreeIdentityContent - Free the contents of an identity. + * nztifdn - Create an identity from a distinguished name + * nztcts_CipherSpecToStr - Converts the Cipher Spec Code To String + * nztiae_IsAuthEnabled - Checks to see if Authentication is Enabled + * in the current Cipher Spec. + * nztiae_IsEncrEnabled - Checks to see if Encryption is Enabled + * in the current Cipher Spec. + * nztiae_IsHashEnabled - Checks to see if Hashing is Enabled + * in the current Cipher Spec. + * nztwGetCertInfo - Get peer certificate info + * + * NOTE: the '+' indicates that these functions are UNSUPPORTED at this time. + * + * NOTES + * + * MODIFIED + * shiahuan 11/28/07 - + * skalyana 08/15/07 - + * pkale 09/28/06 - Bug 5565668: Removed __STDC__ + * tnallath 09/22/05 - + * rchahal 07/27/04 - add keyusage + * srtata 11/10/03 - fix nztSetAppDefaultLocation header + * rchahal 10/15/03 - bug 2513821 + * rchahal 11/11/02 - pkcs11 support + * akoyfman 07/05/02 - adding secret store to persona + * supriya 10/11/01 - Fix for bug # 2015732 + * ajacobs 04/04/01 - make NZT_REGISTRY_WRL always available + * ajacobs 03/06/01 - olint fix + * ajacobs 03/02/01 - Add GetCertInfo + * supriya 02/23/01 - Move nzttKPUsage from nzt0.h + * rchahal 01/26/01 - olint fixes + * supriya 12/07/00 - Change fn name + * supriya 12/01/00 - Certificate API's needed for iAS + * supriya 06/19/00 - Adding definitions for MCS and ENTR + * lkethana 05/31/00 - multiple cert support + * skanjila 06/25/99 - Remove nztcts_CipherSpecToStr() to NZOS. + * skanjila 06/23/99 - Change API of nztcts_CipherSpecToStr. + * lkethana 06/18/99 - rem nztIPrivateAlloc, etc + * lkethana 06/10/99 - changing size_t to ub4 + * lkethana 06/02/99 - add api for getting auth/encry/hash capability of c + * arswamin 12/28/98 - add NZT_MAX_MD5. + * arswamin 12/21/98 - change signature of compareDN + * qdinh 12/21/98 - change size_t to ub4. + * inetwork 11/22/98 - Removing NZDEPRECATED definition + * amthakur 09/14/98 - deprecating and updating the c-structures. + * arswamin 09/24/98 - adding NZTTWRL_NULL for SSO support. + * amthakur 07/30/98 - changing the prototype of nztGetCertChain. + * qdinh 05/01/98 - add NZTTIDENTTYPE_INVALID_TYPE + * qdinh 04/17/98 - add NZTTWRL_ORACLE. + * ascott 10/08/97 - implement nztiStoreTrustedIdentity + * ascott 10/07/97 - add nztiGetIdentityDesc + * ascott 09/28/97 - clarify prototype comments and error codes + * ascott 09/05/97 - update identity: create, destroy, duplicate + * ascott 08/21/97 - add GetCert and GetPriKey + * ascott 08/07/97 - add other WRL settings + * asriniva 03/25/97 - Add ANSI prototypes + * rwessman 03/19/97 - Added prototypes for nztific_FreeIdentityContent() + * asriniva 03/11/97 - Fix olint errors + * sdange 02/28/97 - Removed inclusion of nz0decl.h + * sdange 02/18/97 - Moved nzt specific declarations from nz0decl.h + * asriniva 01/21/97 - Remove prototypes. + * asriniva 10/31/96 - Include oratypes.h + * asriniva 10/15/96 - Declare buffer block helper functions + * asriniva 10/08/96 - First pass at wallet open/close + * asriniva 10/04/96 - Add random number seed function + * asriniva 10/03/96 - Reorder parameters in nztbbSetBlock + * asriniva 10/03/96 - Keep editing. + * asriniva 10/03/96 - Continued edits. + * asriniva 10/02/96 - Continue editing. + * asriniva 09/26/96 - + */ + +/* ENABLE check_long_lines */ + +#ifndef NZT_ORACLE +#define NZT_ORACLE + +#ifndef ORATYPES +# include +#endif /* ORATYPES */ + +#ifndef NZERROR_ORACLE +# include /* NZ error type */ +#endif /* NZERROR_ORACLE */ + + +#define NZT_MAX_SHA1 20 +#define NZT_MAX_MD5 16 + +/***************************************/ +/* PUBLIC CONSTANTS, MACROS, AND TYPES */ +/***************************************/ + +/* + * Wallet Resource Locator Type Strings + * + * WRL TYPE PARAMETERS BEHAVIOR + * ======== ========== ===================================== + * default: Uses directory defined by the parameter + * SNZD_DEFAULT_FILE_DIRECTORY which in + * unix is "$HOME/oracle/oss" + * + * file: file path Find the Oracle wallet in this directory. + * example: file: + * + * sqlnet: In this case, the directory path will be + * retrieved from the sqlnet.ora file under + * the oss.source.my_wallet parameter. + * + * mcs: Microsoft WRL. + * + * entr: dir path Entrust WRL. eg: ENTR: + * + */ +/* Note that there is no NZT_NULL_WRL. Instead look in snzd.h for DEFAULT_WRP + * which is used in our new defaulting mechanism. The NZT_DEFAULT_WRL + * should be deprecated. + */ +#define NZT_DEFAULT_WRL ((text *)"default:") +#define NZT_SQLNET_WRL ((text *)"sqlnet:") +#define NZT_FILE_WRL ((text *)"file:") +#define NZT_ENTR_WRL ((text *)"entr:") +#define NZT_MCS_WRL ((text *)"mcs:") +#define NZT_ORACLE_WRL ((text *)"oracle:") +#define NZT_REGISTRY_WRL ((text *)"reg:") + +enum nzttwrl +{ + NZTTWRL_DEFAULT = 1, /* Default, use SNZD_DEFAULT_FILE_DIRECTORY */ + NZTTWRL_SQLNET, /* Use oss.source.my_wallet in sqlnet.ora file */ + NZTTWRL_FILE, /* Find the oracle wallet in this directory */ + NZTTWRL_ENTR, /* Find the entrust profile in this directory */ + NZTTWRL_MCS, /* WRL for Microsoft */ + NZTTWRL_ORACLE, /* Get the wallet from OSS db */ + NZTTWRL_NULL, /* New SSO defaulting mechanism */ + NZTTWRL_REGISTRY /* Find the wallet in Windows Registry */ +}; +typedef enum nzttwrl nzttwrl; + +#ifndef NZ0DECL_ORACLE + /* + * With the elimination of nz0decl.h from public, we need this + * redundant typedef. + */ + typedef struct nzctx nzctx; + typedef struct nzstrc nzstrc; + typedef struct nzosContext nzosContext; +#endif /* NZ0DECL_ORACLE */ + +/* Moved from nz0decl.h */ + +typedef struct nzttIdentity nzttIdentity; +typedef struct nzttIdentityPrivate nzttIdentityPrivate; +typedef struct nzttPersona nzttPersona; +typedef struct nzttPersonaPrivate nzttPersonaPrivate; +typedef struct nzttWallet nzttWallet; +typedef struct nzttWalletPrivate nzttWalletPrivate; +typedef struct nzttWalletObj nzttWalletObj; /* For wallet object */ +typedef struct nzssEntry nzssEntry; /* For secretstore */ +typedef struct nzpkcs11_Info nzpkcs11_Info; + +/* + * Crypto Engine State + * + * Once the crypto engine (CE) has been initialized for a particular + * cipher, it is either at the initial state, or it is continuing to + * use the cipher. NZTCES_END is used to change the state back to + * initialized and flush any remaining output. NZTTCES_RESET can be + * used to change the state back to initialized and throw away any + * remaining output. + */ +enum nzttces +{ + NZTTCES_CONTINUE = 1, /* Continue processing input */ + NZTTCES_END, /* End processing input */ + NZTTCES_RESET /* Reset processing and skip generating output */ +}; +typedef enum nzttces nzttces; + +/* + * Crypto Engine Functions + * + * List of crypto engine categories; used to index into protection + * vector. + */ +enum nzttcef +{ + NZTTCEF_DETACHEDSIGNATURE = 1, /* Signature, detached from content */ + NZTTCEF_SIGNATURE, /* Signature combined with content */ + NZTTCEF_ENVELOPING, /* Signature and encryption with content */ + NZTTCEF_PKENCRYPTION, /* Encryption for one or more recipients */ + NZTTCEF_ENCRYPTION, /* Symmetric encryption */ + NZTTCEF_KEYEDHASH, /* Keyed hash/checkusm */ + NZTTCEF_HASH, /* Hash/checsum */ + NZTTCEF_RANDOM, /* Random byte generation */ + + NZTTCEF_LAST /* Used for array size */ +}; +typedef enum nzttcef nzttcef; + +/* + * State of the persona. + */ +enum nzttState +{ + NZTTSTATE_EMPTY = 0, /* is not in any state(senseless???) */ + NZTTSTATE_REQUESTED, /* cert-request */ + NZTTSTATE_READY, /* certificate */ + NZTTSTATE_INVALID, /* certificate */ + NZTTSTATE_RENEWAL /* renewal-requested */ +}; +typedef enum nzttState nzttState; + +/* + * Cert-version types + * + * This is used to quickly look-up the cert-type + */ +enum nzttVersion +{ + NZTTVERSION_X509v1 = 1, /* X.509v1 */ + NZTTVERSION_X509v3, /* X.509v3 */ +#ifdef NZDEPRECATED + NZTTVERSION_SYMMETRIC, /* Symmetric */ +#endif + NZTTVERSION_INVALID_TYPE /* For Initialization */ +}; +typedef enum nzttVersion nzttVersion; + +/* + * Cipher Types + * + * List of all cryptographic algorithms, some of which may not be + * available. + */ +enum nzttCipherType +{ + NZTTCIPHERTYPE_RSA = 1, /* RSA public key */ + NZTTCIPHERTYPE_DES, /* DES */ + NZTTCIPHERTYPE_RC4, /* RC4 */ + NZTTCIPHERTYPE_MD5DES, /* DES encrypted MD5 with salt (PBE) */ + NZTTCIPHERTYPE_MD5RC2, /* RC2 encrypted MD5 with salt (PBE) */ + NZTTCIPHERTYPE_MD5, /* MD5 */ + NZTTCIPHERTYPE_SHA /* SHA */ +}; +typedef enum nzttCipherType nzttCipherType; + +/* + * TDU Formats + * + * List of possible toolkit data unit (TDU) formats. Depending on the + * function and cipher used some may be not be available. + */ +enum nztttdufmt +{ + NZTTTDUFMT_PKCS7 = 1, /* PKCS7 format */ + NZTTTDUFMT_RSAPAD, /* RSA padded format */ + NZTTTDUFMT_ORACLEv1, /* Oracle v1 format */ + NZTTTDUFMT_LAST /* Used for array size */ +}; +typedef enum nztttdufmt nztttdufmt; + +/* + * Validate State + * + * Possible validation states an identity can be in. + */ +enum nzttValState +{ + NZTTVALSTATE_NONE = 1, /* Needs to be validated */ + NZTTVALSTATE_GOOD, /* Validated */ + NZTTVALSTATE_REVOKED /* Failed to validate */ +}; +typedef enum nzttValState nzttValState; + +/* + * Policy Fields <----NEW (09/14/98) + * + * Policies enforced + */ +enum nzttPolicy +{ + NZTTPOLICY_NONE = 0, + NZTTPOLICY_RETRY_1, /* number of retries for decryption = 1 */ + NZTTPOLICY_RETRY_2, /* number of retries for decryption = 2 */ + NZTTPOLICY_RETRY_3 /* number of retries for decryption = 3 */ +}; +typedef enum nzttPolicy nzttPolicy; + +/* + * Persona Usage <----NEW (09/14/98) + * + * what a persona will be used for? + */ + +#ifdef NZDEPRECATED_MULTIPLECERTS +enum nzttUsage +{ + NZTTUSAGE_NONE = 0, + NZTTUSAGE_SSL /* persona for SSL usage */ +}; +typedef enum nzttUsage nzttUsage; +#endif + +/* + * Personas and identities have unique id's that are represented with + * 128 bits. + */ +typedef ub1 nzttID[16]; + +/* + * Identity Types + * + * List of all Identity types.. + */ +enum nzttIdentType +{ + NZTTIDENTITYTYPE_INVALID_TYPE = 0, + NZTTIDENTITYTYPE_CERTIFICTAE, + NZTTIDENTITYTYPE_CERT_REQ, + NZTTIDENTITYTYPE_RENEW_CERT_REQ, + NZTTIDENTITYTYPE_CLEAR_ETP, + NZTTIDENTITYTYPE_CLEAR_UTP, + NZTTIDENTITYTYPE_CLEAR_PTP +}; +typedef enum nzttIdentType nzttIdentType; + +typedef ub4 nzttKPUsage; +/* IF new types are added nztiMUS should be changed */ +#define NZTTKPUSAGE_NONE 0 +#define NZTTKPUSAGE_SSL 1 /* SSL Server */ +#define NZTTKPUSAGE_SMIME_ENCR 2 +#define NZTTKPUSAGE_SMIME_SIGN 4 +#define NZTTKPUSAGE_CODE_SIGN 8 +#define NZTTKPUSAGE_CERT_SIGN 16 +#define NZTTKPUSAGE_SSL_CLIENT 32 /* SSL Client */ +#define NZTTKPUSAGE_INVALID_USE 0xffff + + +/* + * Timestamp as 32 bit quantity in UTC. + */ +typedef ub1 nzttTStamp[4]; + +/* + * Buffer Block + * + * A function that needs to fill (and possibly grow) an output buffer + * uses an output parameter block to describe each buffer. + * + * The flags_nzttBufferBlock member tells the function whether the + * buffer can be grown or not. If flags_nzttBufferBlock is 0, then + * the buffer will be realloc'ed automatically. + * + * The buflen_nzttBufferBLock member is set to the length of the + * buffer before the function is called and will be the length of the + * buffer when the function is finished. If buflen_nzttBufferBlock is + * 0, then the initial pointer stored in pobj_nzttBufferBlock is + * ignored. + * + * The objlen_nzttBufferBlock member is set to the length of the + * object stored in the buffer when the function is finished. If the + * initial buffer had a non-0 length, then it is possible that the + * object length is shorter than the buffer length. + * + * The pobj_nzttBufferBlock member is a pointer to the output object. + */ +struct nzttBufferBlock +{ +# define NZT_NO_AUTO_REALLOC 0x1 + + uword flags_nzttBufferBlock; /* Flags */ + ub4 buflen_nzttBufferBlock; /* Total length of buffer */ + ub4 usedlen_nzttBufferBlock; /* Length of used buffer part */ + ub1 *buffer_nzttBufferBlock; /* Pointer to buffer */ +}; +typedef struct nzttBufferBlock nzttBufferBlock; + +/* + * Wallet. + */ +struct nzttWallet +{ + ub1 *ldapName_nzttWallet; /* user's LDAP Name */ + ub4 ldapNamelen_nzttWallet; /* len of user's LDAP Name */ + nzttPolicy securePolicy_nzttWallet; /* secured-policy of the wallet */ + nzttPolicy openPolicy_nzttWallet; /* open-policy of the wallet */ + nzttPersona *persona_nzttWallet; /* List of personas in wallet */ + nzttWalletPrivate *private_nzttWallet; /* Private wallet information */ +#ifdef NZDEPRECATED + ub4 npersona_nzttWallet; /* Number of personas */ +#endif +}; + +/* + * The wallet contains, one or more personas. A persona always + * contains its private key and its identity. It may also contain + * other 3rd party identites. All identities qualified with trust + * where the qualifier can indicate anything from untrusted to trusted + * for specific operations. + */ + +/* + * Persona + * + * Structure containing information about a persona. + */ +struct nzttPersona +{ + ub1 *genericName_nzttPersona; /* user-friendly persona name */ + ub4 genericNamelen_nzttPersona; /* persona-name length */ + nzttPersonaPrivate *private_nzttPersona; /* Opaque part of persona */ + nzttIdentity *mycertreqs_nzttPersona; /* My cert-requests */ + nzttIdentity *mycerts_nzttPersona; /* My certificates */ + nzttIdentity *mytps_nzttPersona; /* List of trusted identities */ + nzssEntry *mystore_nzttPersona; /* List of secrets */ + nzpkcs11_Info *mypkcs11Info_nzttPersona; /* PKCS11 token info */ + struct nzttPersona *next_nzttPersona; /* Next persona */ +#ifdef NZDEPRECATED_MULTIPLECERTS + /* As Persona has multiple certs for different + usages, Persona Usage does not mean anything. Similarly + each key pair has its own state and Persona state itself + does not mean anything. - lk 5/31/00 + */ + nzttUsage usage_nzttPersona; /* persona usage; SSL/SET/.. */ + nzttState state_nzttPersona; /* persona state-requested/ready */ + ub4 ntps_nzttPersona; /* Num of trusted identities */ +#endif +}; + +/* + * Identity + * + * Structure containing information about an identity. + * + * NOTE + * -- the next_trustpoint field only applies to trusted identities and + * has no meaning (i.e. is NULL) for self identities. + */ +struct nzttIdentity +{ + text *dn_nzttIdentity; /* Alias */ + ub4 dnlen_nzttIdentity; /* Length of alias */ + text *comment_nzttIdentity; /* Comment */ + ub4 commentlen_nzttIdentity; /* Length of comment */ + nzttIdentityPrivate *private_nzttIdentity; /* Opaque part of identity */ + nzttIdentity *next_nzttIdentity; /* next identity in list */ +}; + +struct nzttB64Cert +{ + ub1 *b64Cert_nzttB64Cert; + ub4 b64Certlen_nzttB64Cert; + struct nzttB64Cert *next_nzttB64Cert; +}; +typedef struct nzttB64Cert nzttB64Cert; + + +struct nzttPKCS7ProtInfo +{ + nzttCipherType mictype_nzttPKCS7ProtInfo; /* Hash cipher */ + nzttCipherType symmtype_nzttPKCS7ProtInfo; /* Symmetric cipher */ + ub4 keylen_nzttPKCS7ProtInfo; /* Length of key to use */ +}; +typedef struct nzttPKCS7ProtInfo nzttPKCS7ProtInfo; + +/* + * Protection Information. + * + * Information specific to a type of protection. + */ +union nzttProtInfo +{ + nzttPKCS7ProtInfo pkcs7_nzttProtInfo; +}; +typedef union nzttProtInfo nzttProtInfo; + +/* + * A description of a persona so that the toolkit can create one. A + * persona can be symmetric or asymmetric and both contain an + * identity. The identity for an asymmetric persona will be the + * certificate and the identity for the symmetric persona will be + * descriptive information about the persona. In either case, an + * identity will have been created before the persona is created. + * + * A persona can be stored separately from the wallet that references + * it. By default, a persona is stored with the wallet (it inherits + * with WRL used to open the wallet). If a WRL is specified, then it + * is used to store the actuall persona and the wallet will have a + * reference to it. + */ +struct nzttPersonaDesc +{ + ub4 privlen_nzttPersonaDesc; /* Length of private info (key)*/ + ub1 *priv_nzttPersonaDesc; /* Private information */ + ub4 prllen_nzttPersonaDesc; /* Length of PRL */ + text *prl_nzttPersonaDesc; /* PRL for storage */ + ub4 aliaslen_nzttPersonaDesc; /* Length of alias */ + text *alias_nzttPersonaDesc; /* Alias */ + ub4 longlen_nzttPersonaDesc; /* Length of longer description*/ + text *long_nzttPersonaDesc; /* Longer persona description */ +}; +typedef struct nzttPersonaDesc nzttPersonaDesc; + +/* + * A description of an identity so that the toolkit can create one. + * Since an identity can be symmetric or asymmetric, the asymmetric + * identity information will not be used when a symmetric identity is + * created. This means the publen_nzttIdentityDesc and + * pub_nzttIdentityDesc members will not be used when creating a + * symmetric identity. + */ +struct nzttIdentityDesc +{ + ub4 publen_nzttIdentityDesc; /* Length of identity */ + ub1 *pub_nzttIdentityDesc; /* Type specific identity */ + ub4 dnlen_nzttIdentityDesc; /* Length of alias */ + text *dn_nzttIdentityDesc; /* Alias */ + ub4 longlen_nzttIdentityDesc; /* Length of longer description */ + text *long_nzttIdentityDesc; /* Longer description */ + ub4 quallen_nzttIdentityDesc; /* Length of trust qualifier */ + text *trustqual_nzttIdentityDesc; /* Trust qualifier */ +}; +typedef struct nzttIdentityDesc nzttIdentityDesc; + +/********************************/ +/* PUBLIC FUNCTION DECLARATIONS */ +/********************************/ + +/*---------------------- nztwOpenWallet ----------------------*/ + +/* + * NAME + * nztwOpenWallet - Open a wallet based on a wallet Resource Locator (WRL). + * + * PARAMETERS + * osscntxt {IN} OSS context. + * wrllen {IN} Length of WRL. + * wrl {IN} WRL. + * pwdlen {IN} Length of password. + * pwd {IN} Password. + * wallet {IN/OUT} Initialized wallet structure. + * + * NOTES + * The syntax for a WRL is :. + * + * Wallet Type Wallet Type Parameters. + * ----------- ---------------------- + * File Pathname (e.g. "file:/home/asriniva") + * Oracle Connect string (e.g. "oracle:scott/tiger@oss") + * + * There are also defaults. If the WRL is NZT_DEFAULT_WRL, then + * the platform specific WRL default is used. If only the wallet + * type is specified, then the WRL type specific default is used + * (e.g. "oracle:") + * + * There is an implication with Oracle that should be stated: An + * Oracle based wallet can be implemented in a user's private space + * or in world readable space. + * + * When the wallet is opened, the password is verified by hashing + * it and comparing against the password hash stored with the + * wallet. The list of personas (and their associated identities) + * is built and stored into the wallet structure. + * + * RETURNS + * NZERROR_OK Success. + * NZERROR_RIO_OPEN RIO could not open wallet (see network trace file). + * NZERROR_TK_PASSWORD Password verification failed. + * NZERROR_TK_WRLTYPE WRL type is not known. + * NZERROR_TK_WRLPARM WRL parm does not match type. + */ +nzerror nztwOpenWallet( nzctx *, ub4, text *, ub4, text *, + nzttWallet * ); + + +/*---------------------- nztwCloseWallet ----------------------*/ + +/* + * NAME + * nztwCloseWallet - Close a wallet + * + * PARAMETERS + * osscntxt {IN} OSS context. + * wallet {IN/OUT} Wallet. + * + * NOTES + * Closing a wallet also closes all personas associated with that + * wallet. It does not cause a persona to automatically be saved + * if it has changed. The implication is that a persona can be + * modified by an application but if it is not explicitly saved it + * reverts back to what was in the wallet. + * + * RETURNS + * NZERROR_OK Success. + * NZERROR_RIO_CLOSE RIO could not close wallet (see network trace file). + */ +nzerror nztwCloseWallet( nzctx *, nzttWallet * ); + +/*--------------------nztwGetCertInfo----------------------------*/ +/****NOTE: This function is a temporary hack.****/ +/****DO NOT CALL. It will soon disappear.****/ +nzerror nztwGetCertInfo( nzctx *nz_context, + nzosContext *nzosCtx, + nzttWallet *walletRef, + void *peerCert ); + + +/*------------------------ nztwConstructWallet -----------------------*/ +/* + * + * nzerror nztwConstructWallet( nzctx *oss_context, + * nzttPolicy openPolicy, + * nzttPolicy securePolicy, + * ub1 *ldapName, + * ub4 ldapNamelen, + * nzstrc *wrl, + * nzttPersona *personas, + * nzttWallet **wallet ); + */ + +/*---------------------- nztwRetrievePersonaCopy ----------------------*/ + +/* + * NAME + * nztwRetrievePersonaCopy - Retrieves a persona based from wallet + * + * PARAMETERS + * osscntxt {IN} OSS context. + * wallet {IN} Wallet. + * index {IN} Which wallet index to remove (first persona is zero). + * persona {OUT} Persona found. + * + * NOTES + * Retrieves a persona from the wallet based on the index number passed + * in. This persona is a COPY of the one stored in the wallet, therefore + * it is perfectly fine for the wallet to be closed after this call is + * made. + * + * The caller is responsible for disposing of the persona when completed. + * + * RETURNS + * NZERROR_OK Success. + */ +nzerror nztwRetrievePersonaCopy( nzctx *, nzttWallet *, ub4, + nzttPersona ** ); + + +/*---------------------- nztwRetrievePersonaCopyByName ----------------------*/ + +/* + * NAME + * nztwRetrievePersonaCopyByName - Retrieves a persona based on its name. + * + * PARAMETERS + * osscntxt {IN} OSS context. + * wallet {IN} Wallet. + * name {IN} Name of the persona + * persona {OUT} Persona found. + * + * NOTES + * Retrieves a persona from the wallet based on the name of the persona. + * This persona is a COPY of the one stored in the wallet, therefore + * it is perfectly fine for the wallet to be closed after this call is + * made. + * + * The caller is responsible for disposing of the persona when completed. + * + * RETURNS + * NZERROR_OK Success. + */ +nzerror nztwRetrievePersonaCopyByName( nzctx *, nzttWallet *, char *, + nzttPersona ** ); + +/*---------------------- nzteOpenPersona ----------------------*/ + +/* + * NAME + * nzteOpenPersona - Open a persona. + * + * PARAMETERS + * osscntxt {IN} OSS context. + * persona {IN/OUT} Persona. + * + * NOTES + * + * RETURNS + * NZERROR_OK Success. + * NZERROR_TK_PASSWORD Password failed to decrypt persona. + * NZERROR_TK_BADPRL Persona resource locator did not work. + * NZERROR_RIO_OPEN Could not open persona (see network trace file). + */ +nzerror nzteOpenPersona( nzctx *, nzttPersona * ); + +/*--------------------- nzteClosePersona ---------------------*/ + +/* + * NAME + * nzteClosePersona - Close a persona. + * + * PARAMETERS + * osscntxt {IN} OSS context. + * persona {IN/OUT} Persona. + * + * NOTES + * Closing a persona does not store the persona, it simply releases + * the memory associated with the crypto engine. + * + * RETURNS + * NZERROR_OK Success. + */ +nzerror nzteClosePersona( nzctx *, nzttPersona * ); + +/*--------------------- nzteDestroyPersona ---------------------*/ + +/* + * NAME + * nzteDestroyPersona - Destroy a persona. + * + * PARAMETERS + * osscntxt {IN} OSS context. + * persona {IN/OUT} Persona. + * + * NOTES + * The persona is destroyd in the open state, but it will + * not be associated with a wallet. + * + * The persona parameter is doubly indirect so that at the + * conclusion of the function, the pointer can be set to NULL. + * + * + * RETURNS + * NZERROR_OK Success. + * NZERROR_TK_TYPE Unsupported itype/ctype combination. + * NZERROR_TK_PARMS Error in persona description. + */ +nzerror nzteDestroyPersona( nzctx *, nzttPersona ** ); + +/*---------------------- nzteRetrieveTrustedIdentCopy ----------------------*/ + +/* + * NAME + * nzteRetrieveTrustedIdentCopy - Retrieves a trusted identity from persona + * + * PARAMETERS + * osscntxt {IN} OSS context. + * persona {IN} Persona. + * index {IN} Which wallet index to remove (first element is zero). + * identity {OUT} Trusted Identity from this persona. + * + * NOTES + * Retrieves a trusted identity from the persona based on the index + * number passed in. This identity is a COPY of the one stored in + * the persona, therefore it is perfectly fine to close the persona + * after this call is made. + * + * The caller is responsible for freeing the memory of this object + * by calling nztiAbortIdentity it is no longer needed + * + * RETURNS + * NZERROR_OK Success. + */ +nzerror nzteRetrieveTrustedIdentCopy( nzctx *, nzttPersona *, ub4, + nzttIdentity ** ); + +/*--------------------- nztePriKey ---------------------*/ + +/* + * NAME + * nztePriKey - Get the decrypted Private Key for the Persona + * + * PARAMETERS + * osscntxt {IN} OSS context. + * persona {IN} Persona. + * vkey {OUT} Private Key [B_KEY_OBJ] + * vkey_len {OUT} Private Key Length + * + * NOTES + * This funiction will only work for X.509 based persona which contain + * a private key. + * A copy of the private key is returned to the caller so that they do not + * have to worry about the key changeing "underneath them". + * Memory will be allocated for the vkey and therefore, the CALLER + * will be responsible for freeing this memory. + * + * RETURNS + * NZERROR_OK Success. + * NZERROR_NO_MEMORY ossctx is null. + * NZERROR_TK_BADPRL Persona resource locator did not work. + */ +nzerror nztePriKey( nzctx *, nzttPersona *, ub1 **, ub4 * ); + +/*--------------------- nzteMyCert ---------------------*/ + +/* + * NAME + * nzteMyCert - Get the X.509 Certificate for a persona + * + * PARAMETERS + * osscntxt {IN} OSS context. + * persona {IN} Persona. + * cert {OUT} X.509 Certificate [BER encoded] + * cert_len {OUT} Certificate length + * + * NOTES + * This funiction will only work for X.509 based persona which contain + * a certificate for the self identity. + * A copy of the certificate is returned to the caller so that they do not + * have to worry about the certificate changeing "underneath them". + * Memory will be allocated for the cert and therefore, the CALLER + * will be responsible for freeing this memory. + * + * RETURNS + * NZERROR_OK Success. + * NZERROR_NO_MEMORY ossctx is null. + */ +nzerror nzteMyCert( nzctx *, nzttPersona *, ub1 **, ub4 * ); + +/*--------------------- nzteX509CreatePersona ---------------------*/ + +/* + * NAME + * nzteX509CreatePersona - Given a BER X.509 cert, create a persona + * + * PARAMETERS + * osscntxt {IN} OSS context. + * cert {IN} X.509 Certificate [BER encoded] + * cert_len {IN} Certificate length + * persona {OUT} Persona. + * + * NOTES + * Memory will be allocated for the persona and therefore, the CALLER + * will be responsible for freeing this memory. + * + * RETURNS + * NZERROR_OK Success. + * NZERROR_NO_MEMORY ossctx is null. + */ +nzerror nzteX509CreatePersona( nzctx *, ub1 *, ub4, nzttPersona ** ); + +/*-------------------- nztiCreateIdentity --------------------*/ + +/* + * NAME + * nztiCreateIdentity - Create an identity. + * + * PARAMETERS + * osscntxt {IN} OSS context. + * itype {IN} Identity type. + * desc {IN} Description of identity. + * identity {IN/OUT} Identity. + * + * NOTES + * Memory is only allocated for the identity structure. The elements in + * the description struct are not copied. Rather their pointers are copied + * into the identity structure. Therefore, the caller should not free + * the elements referenced by the desc. These elements will be freed + * when the nztiDestroyIdentity is called. + * + * RETURNS + * NZERROR_OK Success. + * NZERROR_PARMS Error in description. + */ +nzerror nztiCreateIdentity( nzctx *, nzttVersion, nzttIdentityDesc *, + nzttIdentity ** ); + +#ifdef NZ_OLD_TOOLS +/*-------------------- nztiDuplicateIdentity --------------------*/ + +/* + * NAME + * nztiDuplicateIdentity - Duplicate an identity. + * + * PARAMETERS + * osscntxt {IN} OSS context. + * identity {IN} Target Identity. + * new_identity {IN} New Identity. + * + * NOTES + * Memory for the identity is allocated inside the function, and all + * internal identity elements as well. + * + * RETURNS + * NZERROR_OK Success. + * NZERROR_TK_NOTFOUND Identity not found. + * NZERROR_PARMS Error in description. + */ +nzerror nztiDuplicateIdentity( nzctx *, nzttIdentity *, + nzttIdentity ** ); +#endif /* NZ_OLD_TOOLS */ + +/*--------------------- nztiAbortIdentity ---------------------*/ + +/* + * NAME + * nztiAbortIdentity - Abort an unassociated identity. + * + * PARAMETERS + * osscntxt {IN} OSS context. + * identity {IN/OUT} Identity. + * + * NOTES + * It is an error to try to abort an identity that can be + * referenced through a persona. + * + * The identity pointer is set to NULL at the conclusion. + * + * RETURNS + * NZERROR_OK Success. + * NZERROR_CANTABORT Identity is associated with persona. + */ +nzerror nztiAbortIdentity( nzctx *, nzttIdentity ** ); + +#ifdef NZ_OLD_TOOLS +/*----------------- nztidGetIdentityDesc -----------------*/ + +/* + * NAME + * nztidGetIdentityDesc - Gets an Identity Description from the identity + * + * PARAMETERS + * osscntxt {IN} Success. + * identity {IN} Identity. + * description {IN/OUT} Identity Description. + * + * NOTES + * Memory is allocated for the Identity Description. It + * is the callers responsibility to free this memory by calling + * nztiFreeIdentityDesc. + * + * RETURNS + * NZERROR_OK Success. + */ +nzerror nztidGetIdentityDesc( nzctx *, nzttIdentity *, + nzttIdentityDesc ** ); + +/*----------------- nztidFreeIdentityDesc -----------------*/ + +/* + * NAME + * nztidFreeIdentityDesc - Frees memory for Identity Desc object. + * + * PARAMETERS + * osscntxt {IN} oss context. + * description {IN/OUT} Identity Description. + * + * NOTES + * Memory is freed for all Identity description elements. Pointer is + * then set to null. + * + * RETURNS + * NZERROR_OK Success. + */ +nzerror nztidFreeIdentityDesc( nzctx *, nzttIdentityDesc ** ); +#endif /* NZ_OLD_TOOLS */ + +/*---------------- nztific_FreeIdentityContent ----------------*/ + +/* + * NAME + * nztific_FreeIdentityContent - free the contents of an identity. + * + * PARAMETERS + * osscntxt {IN} OSS context. + * identity {IN/OUT} freed identity + * + * NOTES + * Free a created identity. + * + * RETURNS + * NZERROR_OK Success. + */ +/* + * Free the identity content. + */ +nzerror nztific_FreeIdentityContent( nzctx *ossctx, + nzttIdentity *identity ); + + +/*-------------------------- nztSign --------------------------*/ + +/* + * NAME + * nztSign - Create an attached signature. + * + * PARAMETERS + * osscntxt {IN} OSS context. + * persona {IN} Open persona acting as signer. + * state {IN} State of signature. + * inlen {IN} Length of this input part. + * in {IN} This input part. + * tdubuf {IN/OUT} TDU buffer. + * + * NOTES + * + * RETURNS + * NZERROR_OK Success. + * NZERROR_TK_CANTGROW Needed to grow output buffer but could not. + * NZERROR_TK_NOTOPEN Persona is not open. + * NZERROR_TK_NOTSUPP Function not supported with persona. + */ +nzerror nztSign( nzctx *, nzttPersona *, nzttces, ub4, ub1 *, + nzttBufferBlock * ); + +/*------------------------- nztVerify -------------------------*/ + +/* + * NAME + * nztVerify - Verify an attached signature. + * + * PARAMETERS + * osscntxt {IN} OSS context. + * persona {IN} Persona. + * state {IN} State of verification. + * intdulen {IN} TDU length. + * intdu {IN} TDU. + * out {IN/OUT} Extracted message. + * verified {OUT} TRUE if signature verified. + * validated{OUT} TRUE if signing identity validated. + * identity {OUT} Identity of signing party. + * + * NOTES + * + * RETURNS + * NZERROR_OK Success. + * NZERROR_TK_CANTGROW Needed to grow outptu buffer but could not. + * NZERROR_TK_NOTOPEN Persona is not open. + * NZERROR_TK_NOTSUPP Function not supported with persona. + */ +nzerror nztVerify( nzctx *, nzttPersona *, nzttces, ub4, ub1 *, + nzttBufferBlock *, boolean *, boolean *, + nzttIdentity ** ); + +/*------------------------ nztValidate ------------------------*/ + +/* + * NAME + * nztValidate - Validate an identity. + * + * PARAMETERS + * osscntxt {IN} OSS context. + * persona {IN} Persona. + * identity {IN} Identity. + * validated{OUT} TRUE if identity was validated. + * + * NOTES + * + * RETURNS + * NZERROR_OK Success. + * NZERROR_TK_NOTOPEN Persona is not open. + * NZERROR_TK_NOTSUPP Function not supported with persona. + */ +nzerror nztValidate( nzctx *, nzttPersona *, nzttIdentity *, boolean * ); + +/*-------------------- nztsd_SignDetached --------------------*/ + +/* + * NAME + * nztsd_SignDetached - Generate a detached signature. + * + * PARAMETERS + * osscntxt {IN} OSS context. + * persona {IN} Persona. + * state {IN} State of signature. + * inlen {IN} Length of this input part. + * in {IN} This input part. + * tdubuf {IN/OUT} TDU buffer. + * + * NOTES + * + * RETURNS + * NZERROR_OK Success. + * NZERROR_TK_CANTGROW Needed to grow output buffer but could not. + * NZERROR_TK_NOTOPEN Persona is not open. + * NZERROR_TK_NOTSUPP Function not supported with persona. + */ +nzerror nztsd_SignDetached( nzctx *, nzttPersona *, nzttces, ub4, ub1 *, + nzttBufferBlock * ); + +/*------------------- nztved_VerifyDetached -------------------*/ + +/* + * NAME + * nztved_VerifyDetached - Verify a detached signature. + * + * PARAMETERS + * osscntxt {IN} OSS context. + * persona {IN} Persona. + * state {IN} State of verification. + * inlen {IN} Length of data. + * in {IN} Data. + * intdulen {IN} Input TDU length. + * tdu {IN} Input TDU. + * verified {OUT} TRUE if signature verified. + * validated{OUT} TRUE if signing identity validated. + * identity {OUT} Identity of signing party. + * + * NOTES + * + * RETURNS + * NZERROR_OK Success. + * NZERROR_TK_NOTOPEN Persona is not open. + * NZERROR_TK_NOTSUPP Function not supported with persona. + */ +nzerror nztved_VerifyDetached( nzctx *, nzttPersona *, nzttces, ub4, + ub1 *, ub4, ub1 *, boolean *, boolean *, + nzttIdentity ** ); + +/*--------------------- nztkec_PKEncrypt ---------------------*/ + +/* + * NAME + * nztkec_PKEncrypt - Encrypt data symmetrically, encrypt key asymmetrically + * + * PARAMETERS + * osscntxt {IN} OSS context. + * persona {IN} Persona. + * nrecipients {IN} Number of recipients for this encryption. + * recipients {IN} List of recipients. + * state {IN} State of encryption. + * inlen {IN} Length of this input part. + * in {IN} This input part. + * tdubuf {IN/OUT} TDU buffer. + * + * NOTES + * There is a limitation of 1 recipient (nrecipients = 1) at this + * time. + * + * RETURNS + * NZERROR_OK Success. + * NZERROR_TK_CANTGROW Needed to grow output buffer but could not. + * NZERROR_TK_NOTOPEN Persona is not open. + * NZERROR_TK_NOTSUPP Function not supported with persona. + */ +nzerror nztkec_PKEncrypt( nzctx *, nzttPersona *, ub4, nzttIdentity *, + nzttces, ub4, ub1 *, nzttBufferBlock * ); + +/*---------------- nztxkec_PKEncryptExpansion ----------------*/ + +/* + * NAME + * nztxkec_PKEncryptExpansion - Determine the buffer needed for PKEncrypt + * + * PARAMETERS + * osscntxt {IN} OSS context. + * persona {IN} Persona. + * nrecipients {IN} Number of recipients. + * inlen {IN} Length of input. + * tdulen {out} Length of buffer need. + * + * NOTES + * + * RETURNS + * NZERROR_OK Success. + * NZERROR_TK_NOTOPEN Persona is not open. + * NZERROR_TK_NOTSUPP Function not supported with persona. + */ +nzerror nztxkec_PKEncryptExpansion( nzctx *, nzttPersona *, ub4, ub4, + ub4 * ); + +/*--------------------- nztkdc_PKDecrypt ---------------------*/ + +/* + * NAME + * nztkdc_PKDecrypt - Decrypt a PKEncrypted message. + * + * PARAMETERS + * osscntxt {IN} OSS context. + * persona {IN} Persona. + * state {IN} State of encryption. + * inlen {IN} Length of this input part. + * in {IN} This input part. + * tdubuf {IN/OUT} TDU buffer. + * + * NOTES + * + * RETURNS + * NZERROR_OK Success. + * NZERROR_TK_CANTGROW Needed to grow output buffer but could not. + * NZERROR_TK_NOTOPEN Persona is not open. + * NZERROR_TK_NOTSUPP Function not supported with persona. + */ +nzerror nztkdc_PKDecrypt( nzctx *, nzttPersona *, nzttces, ub4, ub1 *, + nzttBufferBlock * ); + +/*-------------------------- nztHash --------------------------*/ + +/* + * NAME + * nztHash - Generate a hash. + * + * PARAMETERS + * osscntxt {IN} OSS context. + * persona {IN} Persona. + * state {IN} State of hash. + * inlen {IN} Length of this input. + * in {IN} This input. + * tdu {IN/OUT} Output tdu. + * + * NOTES + * + * RETURNS + * NZERROR_OK Success. + * NZERROR_TK_CANTGROW Needed to grow TDU buffer but could not. + * NZERROR_TK_NOTOPEN Persona is not open. + * NZERROR_TK_NOTSUPP Function not supported with persona. + */ +nzerror nztHash( nzctx *, nzttPersona *, nzttces, ub4, ub1 *, + nzttBufferBlock * ); + +/*----------------------- nztSeedRandom -----------------------*/ + +/* + * NAME + * nztSeedRandom - Seed the random function + * + * PARAMETERS + * osscntxt {IN} OSS context. + * persona {IN} Persona. + * seedlen {IN} Length of seed. + * seed {IN} Seed. + * + * NOTES + * + * RETURNS + * NZERROR_OK Success. + * NZERROR_TK_NOTOPEN Persona is not open. + * NZERROR_TK_NOTSUPP Function not supported with persona. + */ +nzerror nztSeedRandom( nzctx *, nzttPersona *, ub4, ub1 * ); + +/*--------------------- nztrb_RandomBytes ---------------------*/ + +/* + * NAME + * nztrb_RandomBytes - Generate a buffer random bytes. + * + * PARAMETERS + * osscntxt {IN} OSS context. + * persona {IN} Persona. + * nbytes {IN} Number of bytes desired. + * out {IN/OUT} Buffer block for bytes. + * + * NOTES + * + * RETURNS + * NZERROR_OK Success. + * NZERROR_TK_CANTGROW Needed to grow TDU buffer but could not. + * NZERROR_TK_NOTOPEN Persona is not open. + * NZERROR_TK_NOTSUPP Function not supported with persona. + */ +nzerror nztrb_RandomBytes( nzctx *, nzttPersona *, ub4, + nzttBufferBlock * ); + +/*-------------------- nztrn_RandomNumber --------------------*/ + +/* + * NAME + * nztrn_RandomNumber - Generate a random number + * + * PARAMETERS + * osscntxt {IN} OSS context. + * persona {IN} Persona. + * num {OUT} Number. + * + * NOTES + * + * RETURNS + * NZERROR_OK Success. + * NZERROR_TK_NOTOPEN Persona is not open. + * NZERROR_TK_NOTSUPP Function not supported with persona. + */ +nzerror nztrn_RandomNumber( nzctx *, nzttPersona *, uword * ); + +/*---------------------- nztbbInitBlock ----------------------*/ + +/* + * NAME + * nztbbInitBlock - Initialize a buffer block. + * + * PARAMETERS + * osscntxt {IN} OSS context. + * block {IN/OUT} Buffer block. + * + * NOTES + * The buffer block is initialized to be empty (all members are set + * to 0/NULL). Such a block will be allocated memory as needed. + * + * RETURNS + * NZERROR_OK Success. + */ +nzerror nztbbInitBlock( nzctx *, nzttBufferBlock * ); + +/*---------------------- nztbbReuseBlock ----------------------*/ + +/* + * NAME + * nztbbReuseBlock - Reuse an already initialized and possibly used block. + * + * PARAMETERS + * osscntxt {IN} OSS context. + * block {IN/OUT} Buffer block. + * + * NOTES + * This function simply sets the used length member of the buffer + * block to 0. If the block already has memory allocated to it, + * this will cause it to be reused. + * + * RETURNS + * NZERROR_OK Success. + */ +nzerror nztbbReuseBlock( nzctx *, nzttBufferBlock * ); + +/*---------------------- nztbbSizeBlock ----------------------*/ + +/* + * NAME + * nztbbSizeBlock - Size an initialized block to a particular size. + * + * PARAMETERS + * osscntxt {IN} OSS context. + * len {IN} Minimum number of unused bytes desired. + * block {IN/OUT} Buffer block. + * + * NOTES + * + * RETURNS + * NZERROR_OK Success. + */ +nzerror nztbbSizeBlock( nzctx *, ub4, nzttBufferBlock * ); + +/*----------------------- nztbbGrowBlock -----------------------*/ + +/* + * NAME + * nzbbGrowBlock - Increase the size of the buffer block. + * + * PARAMETERS + * osscntxt {IN} OSS context. + * inc {IN} Number of bytes to increase. + * block {IN/OUT} Buffer block. + * + * NOTES + * + * RETURNS + * NZERROR_OK Success. + */ +nzerror nztbbGrowBlock( nzctx *, ub4, nzttBufferBlock * ); + +/*---------------------- nztbbPurgeBlock ----------------------*/ + +/* + * NAME + * nztbbPurgeBlock - Purge a buffer block of its memory. + * + * PARAMETERS + * osscntxt {IN} OSS context. + * block {IN/OUT} Buffer block. + * + * NOTES + * The memory used by the buffer block as the buffer is released. + * The buffer block itself is not affected. + * + * RETURNS + * NZERROR_OK Success. + */ +nzerror nztbbPurgeBlock( nzctx *, nzttBufferBlock * ); + +/*----------------------- nztbbSetBlock -----------------------*/ + +/* + * NAME + * nztbbSetBlock - Set a buffer block to a known state. + * + * PARAMETERS + * osscntxt {IN} OSS context. + * flags {IN} Flags to set. + * buflen {IN} Length of buffer. + * usedlen {IN} Used length. + * buffer {IN} Buffer. + * block {IN/OUT} Buffer block + * + * NOTES + * If buflen > 0, objlen == 0, and obj == NULL, then buflen bytes + * of memory is allocated and a pointer is stored in the buffer + * block. + * + * The buffer parameter remains unchanged. + * + * RETURNS + * NZERROR_OK Success. + */ +nzerror nztbbSetBlock( nzctx *, uword, ub4, ub4, ub1 *, + nzttBufferBlock * ); + + +/*--------------------- nztiGetSecInfo ---------------------*/ + +/* + * NAME + * nztiGetSecInfo - Get some security information for SSL + * + * PARAMETERS + * Name {IN/OUT} Description + * osscntxt {IN} OSS context. + * persona {IN} persona + * dname {OUT} distinguished name of the certificate + * dnamelen {OUT} length of the distinguished name + * issuername {OUT} issuer name of the certificate + * certhash {OUT} SHA1 hash of the certificate + * certhashlen{OUT} length of the hash + * NOTES + * This function allocate memories for issuername, certhash, and dname. + * To deallocate memory for those params, you should call nztdbuf_DestroyBuf. + * RETURNS + * + */ +nzerror nztiGetSecInfo( nzctx *, nzttPersona *, text **, ub4 *, + text **, ub4 *, ub1 **, ub4 * ); + + +/*---------------------- nztiGetDName ----------------------*/ + +/* + * NAME + * nztiGetDName - Get the distinguished name for the given identity + * + * PARAMETERS + * Name {IN/OUT} Description + * osscntxt {IN} OSS context. + * identity {IN} identity need to get dname from + * dn {OUT} distinguished name + * dnlen {OUT} length of the dname + * + * NOTES + * + * RETURNS + * + */ + +nzerror nztiGetDName( nzctx *, nzttIdentity *, + text **, ub4 * ); + +/*------------------- nztiGetIssuerName -------------------*/ + +/* + * NAME + * nztiGetIssuerName - Get IssuerName for the given identity + * + * PARAMETERS + * Name {IN/OUT} Description + * osscntxt {IN} OSS context. + * identity {IN} identity need to get issuername from + * issuername {OUT} issuer's name + * issuernamelen {OUT} length of the issuer's name + * + * NOTES + * + * RETURNS + * + */ +nzerror nztiGetIssuerName( nzctx *, nzttIdentity *, + text **, ub4 * ); + + +/*-------------------- nztgch_GetCertHash --------------------*/ + +/* + * NAME + * nztgch_GetCertHash - Get SHA1 hash for the certificate of the identity + * + * PARAMETERS + * Name {IN/OUT} Description + * osscntxt {IN} OSS context. + * identity {IN} identity need to get issuername from + * certHash {OUT} certHash buffer + * hashLen {OUT} length of the certHash + * + * NOTES + * Need to call nztdbuf_DestroyBuf to deallocate memory for certHash. + * RETURNS + * + */ +nzerror nztgch_GetCertHash( nzctx *, nzttIdentity *, + ub1 **, ub4 * ); + +/*-------------------- nztdbuf_DestroyBuf --------------------*/ + +/* + * NAME + * nztdbuf_DestroyBuf - Deallocation funtions for ub1 and text buffer + * + * PARAMETERS + * Name {IN/OUT} Description + * osscntxt {IN} OSS context. + * buf {IN} Allocated buffer to be destroyed. + * + * NOTES + * + * RETURNS + * + */ +nzerror nztdbuf_DestroyBuf( nzctx *, void ** ); + + +/*----------------------- nztGetCertChain -----------------------*/ + +/* + * NAME + * nztGetCertChain - + * + * PARAMETERS + * Name {IN/OUT} Description + * osscntxt {IN} OSS context. + * + * NOTES + * + * RETURNS + * + */ +nzerror nztGetCertChain( nzctx *, nzttWallet * ); + +/*----------------------- nztCompareDN -----------------------*/ + +/* + * NAME + * nztCompareDN - + * + * PARAMETERS + * Name {IN/OUT} Description + * osscntxt {IN} OSS context. + * dn1 {IN} distinguished name 1 + * dn2 {IN} distinguished name 2 + * + * NOTES + * + * RETURNS + * NZERROR_OK succeeded + * others failed + * + */ +nzerror nztCompareDN( nzctx *, ub1 *,ub4 , ub1 *, ub4, boolean * ); + + +#ifdef NZ_OLD_TOOLS +/*--------------------- nztIdentityAlloc ---------------------*/ + +/* + * NAME + * nztIdentityAlloc - Allocate memory for nzttIdentity context + * + * PARAMETERS + * Name {IN/OUT} Description + * osscntxt {IN} OSS context. + * identity {OUT} nzttIdentity context + * + * NOTES + * + * RETURNS + * NZERROR_OK succeeded + * others failed + * + */ +nzerror nztIdentityAlloc( nzctx *, nzttIdentity ** ); + +/*--------------------- nztIPrivateAlloc ---------------------*/ + +/* + * NAME + * nztIPrivateAlloc - Allocate memory for nzttIdentityPrivate + * + * PARAMETERS + * Name {IN/OUT} Description + * + * osscntxt {IN} OSS context. + * ipriv {OUT} identityPrivate structure + * NOTES + * + * RETURNS + * NZERROR_OK succeeded + * others failed + * + */ + +nzerror nztIPrivateAlloc( nzctx *, nzttIdentityPrivate **); + + +/*---------------------- nztIDupContent ----------------------*/ + +/* + * NAME + * nztIDupContent - + * + * PARAMETERS + * Name {IN/OUT} Description + * osscntxt {IN} OSS context. + * targetIdentity{OUT} target identity + * sourceIdentity {IN} source identity + * NOTES + * + * RETURNS + * NZERROR_OK succeeded + * others failed + * + */ + +nzerror nztIDupContent( nzctx *, nzttIdentity *, nzttIdentity * ); +/*---------------------- nztIPDuplicate ----------------------*/ + +/* + * NAME + * nztIPDuplicate - + * + * PARAMETERS + * Name {IN/OUT} Description + * osscntxt {IN} OSS context. + * target_ipriv {OUT} target identityPrivate + * source_ipriv {IN} source identityPrivate + * + * NOTES + * + * RETURNS + * NZERROR_OK succeeded + * others failed + * + */ +nzerror nztIPDuplicate( nzctx *, nzttIdentityPrivate **, + nzttIdentityPrivate * ); + +/*--------------------- nztiDupIdentList ---------------------*/ + +/* + * NAME + * nztiDupIdentList - + * + * PARAMETERS + * Name {IN/OUT} Description + * osscntxt {IN} OSS context. + * source_identities {IN} source identity list + * numIdent {OUT} number of identity in the list + * ppidentity {OUT} Target of identity + * + * NOTES + * + * RETURNS + * NZERROR_OK succeeded + * others failed + * + */ +nzerror nztiDupIdentList( nzctx *, nzttIdentity *, ub4 *, + nzttIdentity ** ); + +/*--------------------- nztFreeIdentList ---------------------*/ + +/* + * NAME + * nztFreeIdentList - Free memory for a list of Identities + * + * PARAMETERS + * Name {IN/OUT} Description + * osscntxt {IN} OSS context. + * identity {IN} identity context + * + * NOTES + * + * RETURNS + * NZERROR_OK succeeded + * others failed + * + */ +nzerror nztFreeIdentList( nzctx *, nzttIdentity ** ); +#endif /* NZ_OLD_TOOLS */ + +/*--------------------- nztCheckVaLidity ---------------------*/ + +/* + * NAME + * nztCheckVaLidity - Check the validity of certificate + * + * PARAMETERS + * Name {IN/OUT} Description + * osscntxt {IN} OSS context. + * start_time Start time of the certificate + * end_time End time of the certificate + * + * NOTES + * + * RETURNS + * NZERROR_OK succeeded + * others failed + * + */ +nzerror nztCheckValidity( nzctx *, ub4 , ub4 ); + +/*--------------------- nztwCreateWallet ---------------------*/ + +/* + * NAME + * nztwCreateWallet - Create a new wallet. + * + * PARAMETERS + * osscntxt {IN} OSS context. + * wrllen {IN} Length of wallet resource locator. + * wrl {IN} WRL. + * pwdlen {IN} Length of password (see notes below). + * pwd {IN} Password. + * wallet {IN/OUT} Wallet. + * + * NOTES + * It is an error to try to create a wallet that already exists. + * The previously existing wallet must be destroyed first. + * + * The wallet itself is not encrypted. Rather, all the personas in + * the wallet are encrypted under the same password. A hash of the + * password is stored in the wallet. + * + * Upon success, an empty open wallet is stored in the wallet + * parameter. + * + * RETURNS + * NZERROR_OK Sucess. + * NZERROR_TK_WALLET_EXISTS Wallet already exists. + * NZERROR_RIO_OPEN RIO could not create wallet (see trace file). + */ +nzerror nztwCreateWallet( nzctx *, ub4, text *, ub4, text *, + nzttWallet * ); + + +/*--------------------- nztwDestroyWallet ---------------------*/ + +/* + * NAME + * nztwDestroyWallet - Destroy an existing wallet. + * + * PARAMETERS + * osscntxt {IN} OSS context. + * wrllen {IN} Length of wallet resource locator. + * wrl {IN} WRL. + * pwdlen {IN} Length of password. + * pwd {IN} Password. + * NOTES + * + * RETURNS + * NZERROR_OK Success. + * NZERROR_TK_PASSWORD Password verification failed. + * NZERROR_RIO_OPEN RIO could not open wallet (see trace file). + * NZERROR_RIO_DELETE Delete failed (see trace file). + */ +nzerror nztwDestroyWallet( nzctx *, ub4, text *, ub4, text * ); + +/*--------------------- nzteStorePersona ---------------------*/ + +/* + * NAME + * nzteStorePersona - Store an open persona in a wallet. + * + * PARAMETERS + * osscntxt {IN} OSS context. + * persona {IN/OUT} Persona. + * wallet {IN/OUT} Wallet. + * + * NOTES + * If the open persona is not associated with any wallet (it was + * created via the nzteClosePersona function), then storing the + * persona creates that association. The wallet will also have an + * updated persona list that reflects this association. + * + * If the open persona was associated with wallet 'A' (it was + * opened via the nztwOpenWallet function), and is stored back into + * wallet 'A', then then the old persona is overwritten by the new + * persona if the password can be verified. Recall that all + * personas have a unique identity id. If that id changes then + * storing the persona will put a new persona in the wallet. + * + * If the open persona was associated with wallet 'A' and is stored + * into wallet 'B', and if wallet 'B' does not contain a persona + * with that unique identity id, then the persona will be copied + * into wallet 'B', wallet 'B''s persona list will be updated, and + * the persona structure will be updated to be associated with + * wallet 'B'. If wallet 'B' already contained the persona, it + * would be overwritten by the new persona. + * + * The persona parameter is doubly indirect so that at the + * conclusion of the function call, the pointer can be directed to + * the persona in the wallet. + * + * RETURNS + * NZERROR_OK Success. + * NZERROR_TK_PASSWORD Password verification failed. + * NZERROR_RIO_STORE Store failed (see network trace file). + */ +nzerror nzteStorePersona( nzctx *, nzttPersona **, nzttWallet * ); + +/*--------------------- nzteRemovePersona ---------------------*/ + +/* + * NAME + * nzteRemovePersona - Remove a persona from the wallet. + * + * PARAMETERS + * osscntxt {IN} OSS context. + * persona {IN/OUT} Persona. + * + * NOTES + * The password is verified before trying to remove the persona. + * + * If the persona is open, it is closed. The persona is removed + * from the wallet list and the persona pointer is set to NULL. + * + * A double indirect pointer to the persona is required so that the + * persona pointer can be set to NULL upon completion. + * + * RETURNS + * NZERROR_OK Success. + * NZERROR_TK_PASSWORD Password verification failed. + * NZERROR_RIO_DELETE Delete failed. + */ +nzerror nzteRemovePersona( nzctx *, nzttPersona ** ); + +/*--------------------- nzteCreatePersona ---------------------*/ + +/* + * NAME + * nzteCreatePersona - Create a persona. + * + * PARAMETERS + * osscntxt {IN} OSS context. + * itype {IN} Identity type. + * ctype {IN} Cipher type. + * desc {IN} Persona description. + * persona {OUT} Persona. + * + * NOTES + * The resulting persona is created in the open state, but it will + * not be associated with a wallet. + * + * The memory for the persona is allocated by the function. + * + * RETURNS + * NZERROR_OK Success. + * NZERROR_TK_TYPE Unsupported itype/ctype combination. + * NZERROR_TK_PARMS Error in persona description. + */ +nzerror nzteCreatePersona( nzctx *, nzttVersion, nzttCipherType, + nzttPersonaDesc *, nzttPersona ** ); + + +/*----------------- nztiStoreTrustedIdentity -----------------*/ + +/* + * NAME + * nztiStoreTrustedIdentity - Store an identity into a persona. + * + * PARAMETERS + * osscntxt {IN} Success. + * identity {IN/OUT} Trusted Identity. + * persona {IN/OUT} Persona. + * + * NOTES + * The identity is not saved with the persona in the wallet until + * the persona is stored. + * + * The identity parameter is double indirect so that it can point + * into the persona at the conclusion of the call. + * + * RETURNS + * NZERROR_OK Success. + */ +nzerror nztiStoreTrustedIdentity( nzctx *, nzttIdentity **, + nzttPersona * ); + +/*--------------------- nzteSetProtection ---------------------*/ + +/* + * NAME + * nzteSetProtection - Set the protection type for a CE function. + * + * PARAMETERS + * osscntxt {IN} OSS context. + * persona {IN/OUT} Persona. + * func {IN} CE function. + * tdufmt {IN} TDU Format. + * protinfo {IN} Protection information specific to this format. + * + * NOTES + * + * RETURNS + * NZERROR_OK Success. + * NZERROR_TK_PROTECTION Unsupported protection. + * NZERROR_TK_PARMS Error in protection info. + */ +nzerror nzteSetProtection( nzctx *, nzttPersona *, nzttcef, nztttdufmt, + nzttProtInfo * ); + +/*--------------------- nzteGetProtection ---------------------*/ + +/* + * NAME + * nzteGetProtection - Get the protection type for a CE function. + * + * PARAMETERS + * osscntxt {IN} OSS context. + * persona {IN} Persona. + * func {IN} CE function. + * tdufmt {OUT} TDU format. + * protinfo {OUT} Protection information. + * + * NOTES + * + * RETURNS + * NZERROR_OK Success. + */ +nzerror nzteGetProtection( nzctx *, nzttPersona *, nzttcef, nztttdufmt *, + nzttProtInfo * ); + +/*-------------------- nztiRemoveIdentity --------------------*/ + +/* + * NAME + * nztiRemoveIdentity - Remove an identity from an open persona. + * + * PARAMETERS + * osscntxt {IN} OSS context. + * identity {IN/OUT} Identity. + * + * NOTES + * If the persona is not stored, this identity will still be in the + * persona stored in the wallet. + * + * The identity parameter is doubly indirect so that at the + * conclusion of the function, the pointer can be set to NULL. + * + * RETURNS + * NZERROR_OK Success. + * NZERROR_TK_NOTFOUND Identity not found. + * NZERROR_TK_NOTOPEN Persona is not open. + */ +nzerror nztiRemoveIdentity( nzctx *, nzttIdentity ** ); + +/*----------------- nztifdn -----------------*/ + +/* + * NAME + * nztifdn - create an Identity From a Distinguished Name + * + * PARAMETERS + * osscntxt {IN} OSS context. + * length {IN} Length of the distinguished name + * distinguished_name {IN} distinguished name string + * ppidentity {OUT} created identity + * + * NOTES + * Given a distinguished name, return the identity that corresponds to it. + * + * RETURNS + * NZERROR_OK Success. + */ +nzerror nztifdn( nzctx *ossctx, + ub4 length, + text *distinguished_name, + nzttIdentity **ppidentity ); + +/*--------------------- nztxSignExpansion ---------------------*/ + +/* + * NAME + * nztxSignExpansion - Determine the size of the attached signature buffer. + * + * PARAMETERS + * osscntxt {IN} OSS context. + * persona {IN} Persona. + * inlen {IN} Length of input. + * tdulen {OUT} Buffer needed for signature. + * + * NOTES + * + * RETURNS + * NZERROR_OK Success. + * NZERROR_TK_NOTOPEN Persona is not open. + * NZERROR_TK_NOTSUPP Function not supported with persona. + */ +nzerror nztxSignExpansion( nzctx *, nzttPersona *, ub4, ub4 * ); + +/*--------------- nztxsd_SignDetachedExpansion ---------------*/ + +/* + * NAME + * nztxsd_SignDetachedExpansion - Determine the size of buffer needed. + * + * PARAMETERS + * osscntxt {IN} OSS context. + * persona {IN} Persona. + * inlen {IN} Length of input. + * tdulen {OUT} Buffer needed for signature. + * + * NOTES + * + * RETURNS + * NZERROR_OK Success. + * NZERROR_TK_NOTOPEN Persona is not open. + * NZERROR_TK_NOTSUPP Function not supported with persona. + */ +nzerror nztxsd_SignDetachedExpansion( nzctx *, nzttPersona *, ub4, + ub4 * ); + +/*------------------------ nztEncrypt ------------------------*/ + +/* + * NAME + * nztEncrypt - Symmetrically encrypt + * + * PARAMETERS + * osscntxt {IN} OSS context. + * persona {IN} Persona. + * inlen {IN} Length of this input part. + * in {IN} This input part. + * tdubuf {IN/OUT} TDU buffer. + * + * NOTES + * + * RETURNS + * NZERROR_OK Success. + * NZERROR_TK_CANTGROW Needed to grow TDU buffer but could not. + * NZERROR_TK_NOTOPEN Persona is not open. + * NZERROR_TK_NOTSUPP Function not supported with persona. + */ +nzerror nztEncrypt( nzctx *, nzttPersona *, nzttces, ub4, ub1 *, + nzttBufferBlock * ); + +/*------------------- nztxEncryptExpansion -------------------*/ + +/* + * NAME + * nztxEncryptExpansion - Determine the size of the TDU to encrypt. + * + * PARAMETERS + * osscntxt {IN} OSS context. + * persona {IN} Persona. + * inlen {IN} Length of this input part. + * tdulen {OUT} Length of TDU. + * + * NOTES + * + * RETURNS + * NZERROR_OK Success. + * NZERROR_TK_NOTOPEN Persona is not open. + * NZERROR_TK_NOTSUPP Function not supported with persona. + */ +nzerror nztxEncryptExpansion( nzctx *, nzttPersona *, ub4, ub4 * ); + +/*------------------------ nztDecrypt ------------------------*/ + +/* + * NAME + * nztDecrypt - Decrypt an Encrypted message. + * + * PARAMETERS + * osscntxt {IN} OSS context. + * persona {IN} Persona. + * state {IN} State of decryption. + * inlen {IN} Length of this input part. + * in {IN} This input part. + * out {IN/OUT} Cleartext message. + * + * NOTES + * + * RETURNS + * NZERROR_OK Success. + * NZERROR_TK_CANTGROW Needed to grow TDU buffer but could not. + * NZERROR_TK_NOTOPEN Persona is not open. + * NZERROR_TK_NOTSUPP Function not supported with persona. + */ +nzerror nztDecrypt( nzctx *, nzttPersona *, nzttces, ub4, ub1 *, + nzttBufferBlock * ); + +/*------------------------ nztEnvelope ------------------------*/ + +/* + * NAME + * nztEnvelope - Sign and PKEncrypt a message. + * + * PARAMETERS + * osscntxt {IN} OSS context. + * persona {IN} Persona. + * nrecipients {IN} Number of recipients for this encryption. + * recipients {IN} List of recipients. + * state {IN} State of encryption. + * inlen {IN} Length of this input part. + * in {IN} This input part. + * tdubuf {IN/OUT} TDU buffer. + * + * NOTES + * + * RETURNS + * NZERROR_OK Success. + * NZERROR_TK_CANTGROW Needed to grow output buffer but could not. + * NZERROR_TK_NOTOPEN Persona is not open. + * NZERROR_TK_NOTSUPP Function not supported with persona. + */ +nzerror nztEnvelope( nzctx *, nzttPersona *, ub4, nzttIdentity *, + nzttces, ub4, ub1 *, nzttBufferBlock * ); + +/*----------------------- nztDeEnvelope -----------------------*/ + +/* + * NAME + * nztDeEnvelope - PKDecrypt and verify a message. + * + * PARAMETERS + * osscntxt {IN} OSS context. + * persona {IN} Persona. + * state {IN} State of encryption. + * inlen {IN} Length of this input part. + * in {IN} This input part. + * out {OUT} Message from TDU. + * verified {OUT} TRUE if verified. + * validated {OUT} TRUE if validated. + * sender {OUT} Identity of sender. + * + * NOTES + * + * RETURNS + * NZERROR_OK Success. + * NZERROR_TK_CANTGROW Needed to grow TDU buffer but could not. + * NZERROR_TK_NOTOPEN Persona is not open. + * NZERROR_TK_NOTSUPP Function not supported with persona. + */ +nzerror nztDeEnvelope( nzctx *, nzttPersona *, nzttces, ub4, ub1 *, + nzttBufferBlock *, boolean *, boolean *, + nzttIdentity ** ); + +/*----------------------- nztKeyedHash -----------------------*/ + +/* + * NAME + * nztKeyedHash - Generate a keyed hash. + * + * PARAMETERS + * osscntxt {IN} OSS context. + * persona {IN} Persona. + * state {IN} State of hash. + * inlen {IN} Length of this input. + * in {IN} This input. + * tdu {IN/OUT} Output tdu. + * + * NOTES + * + * RETURNS + * NZERROR_OK Success. + * NZERROR_TK_CANTGROW Needed to grow TDU buffer but could not. + * NZERROR_TK_NOTOPEN Persona is not open. + * NZERROR_TK_NOTSUPP Function not supported with persona. + */ +nzerror nztKeyedHash( nzctx *, nzttPersona *, nzttces, ub4, ub1 *, + nzttBufferBlock * ); + +/*------------------ nztxKeyedHashExpansion ------------------*/ + +/* + * NAME + * nztxKeyedHashExpansion - Determine the space needed for a keyed hash. + * + * PARAMETERS + * osscntxt {IN} OSS context. + * persona {IN} Persona. + * inlen {IN} Length of this input. + * tdulen {OUT} TDU length. + * + * NOTES + * + * RETURNS + * NZERROR_OK Success. + * NZERROR_TK_NOTOPEN Persona is not open. + * NZERROR_TK_NOTSUPP Function not supported with persona. + */ +nzerror nztxKeyedHashExpansion( nzctx *, nzttPersona *, ub4, + ub4 * ); + +/*--------------------- nztxHashExpansion ---------------------*/ + +/* + * NAME + * nztxHashExpansion - Determine the size of the TDU for a hash. + * + * PARAMETERS + * osscntxt {IN} OSS context. + * persona {IN} Persona. + * inlen {IN} Length of this input. + * tdulen {OUT} TDU length. + * + * NOTES + * + * RETURNS + * NZERROR_OK Success. + * NZERROR_TK_NOTOPEN Persona is not open. + * NZERROR_TK_NOTSUPP Function not supported with persona. + */ +nzerror nztxHashExpansion( nzctx *, nzttPersona *, ub4, ub4 * ); + +/*---------------- nztiae_IsAuthEnabled ----------------*/ + +/* + * NAME + * nztiae_IsAuthEnabled - Checks to see if Authentication is Enabled + * in the current Cipher Spec. + * + * PARAMETERS + * ctx {IN} Oracle SSL Context + * ncipher {IN} CipherSuite + * authEnabled {OUT} Boolean for is Auth Enabled? + * + * NOTES + * + * RETURNS + * NZERROR_OK on success. + * NZERROR_TK_INV_CIPHR_TYPE if Cipher Spec is not Recognized. + */ + +nzerror nztiae_IsAuthEnabled( nzctx *ctx, + ub2 ncipher, + boolean *authEnabled ); + +/*---------------- nztiee_IsEncrEnabled ----------------*/ +/* + * NAME + * nztiee_IsEncrEnabled - Checks to see if Encryption is Enabled + * in the current Cipher Spec. + * + * PARAMETERS + * ctx {IN} Oracle SSL Context + * ncipher {IN} CipherSuite + * EncrEnabled {OUT} Boolean for is Auth Enabled? + * + * NOTES + * + * RETURNS + * NZERROR_OK on success. + * NZERROR_TK_INV_CIPHR_TYPE if Cipher Spec is not Recognized. + */ + +nzerror nztiee_IsEncrEnabled( nzctx *ctx, + ub2 ncipher, + boolean *EncrEnabled ); + +/*---------------- nztihe_IsHashEnabled ----------------*/ +/* + * NAME + * nztihe_IsHashEnabled - Checks to see if HAshing is Enabled + * in the current Cipher Spec. + * + * PARAMETERS + * ctx {IN} Oracle SSL Context + * ncipher {IN} CipherSuite + * hashEnabled {OUT} Boolean for is Auth Enabled? + * + * NOTES + * + * RETURNS + * NZERROR_OK on success. + * NZERROR_TK_INV_CIPHR_TYPE if Cipher Spec is not Recognized. + */ + +nzerror nztihe_IsHashEnabled( nzctx *ctx, + ub2 ncipher, + boolean *hashEnabled ); + +/* + * + */ + +nzerror nztGetIssuerName( nzctx *ctx, + nzttIdentity *identity, + ub1 **issuername, + ub4 *issuernamelen ); + +nzerror nztGetSubjectName( nzctx *ctx, + nzttIdentity *identity, + ub1 **subjectname, + ub4 *subjectnamelen ); + +nzerror nztGetBase64Cert( nzctx *ctx, + nzttIdentity *identity, + ub1 **b64cert, + ub4 *b64certlen ); + +nzerror nztGetSerialNumber( nzctx *ctx, + nzttIdentity *identity, + ub1 **serialnum, + ub4 *serialnumlen ); + +nzerror nztGetValidDate( nzctx *ctx, + nzttIdentity *identity, + ub4 *startdate, + ub4 *enddate ); + +nzerror nztGetVersion( nzctx *ctx, + nzttIdentity *identity, + nzstrc *pVerStr ); + +nzerror nztGetPublicKey( nzctx *ctx, + nzttIdentity *identity, + ub1 **pubKey, + ub4 *pubKeylen ); + +nzerror nztGenericDestroy( nzctx *ctx, + ub1 **var ); + +nzerror nztSetAppDefaultLocation( nzctx *ctx, + text *, + size_t ); + +nzerror nztSearchNZDefault( nzctx *ctx, + boolean *search ); + +nzerror nztSetLightWeight(nzctx *ctx, + boolean flag); + +#endif /* NZT_ORACLE */ + diff --git a/OCI/include/occi.h b/OCI/include/occi.h new file mode 100644 index 0000000..2dca9e6 --- /dev/null +++ b/OCI/include/occi.h @@ -0,0 +1,78 @@ +/* Copyright (c) 2000, 2002, Oracle Corporation. All rights reserved. */ + +/* + NAME + occi.h - Oracle C++ Interface header files. + + DESCRIPTION + + + RELATED DOCUMENTS + + + EXPORT FUNCTION(S) + + + INTERNAL FUNCTION(S) + + + EXAMPLES + + NOTES + + + MODIFIED (MM/DD/YY) + vvinay 08/19/02 - + aahluwal 06/03/02 - bug 2360115 + gayyappa 01/03/01 - removed inclusions before occiCommon.h + kmohan 04/11/00 - include oci.h and occiCommon.h also + rkasamse 04/03/00 - header file for all the OCCI classes + rkasamse 04/03/00 - Creation + +*/ + +#ifndef OCCI_ORACLE +# define OCCI_ORACLE + +#ifndef OCCICOMMON_ORACLE +#include +#endif + +#ifndef OCCIDATA_ORACLE +#include +#endif + +#ifndef OCCICONTROL_ORACLE +#include +#endif + +#ifndef OCCIOBJECTS_ORACLE +#include +#endif + +#ifndef OCCIAQ_ORACLE +#include +#endif + +/*--------------------------------------------------------------------------- + PUBLIC TYPES AND CONSTANTS + ---------------------------------------------------------------------------*/ + + +/*--------------------------------------------------------------------------- + PRIVATE TYPES AND CONSTANTS + ---------------------------------------------------------------------------*/ + + +/*--------------------------------------------------------------------------- + EXPORT FUNCTIONS + ---------------------------------------------------------------------------*/ + + +/*--------------------------------------------------------------------------- + INTERNAL FUNCTIONS + ---------------------------------------------------------------------------*/ + + +#endif /* OCCI_ORACLE */ diff --git a/OCI/include/occiAQ.h b/OCI/include/occiAQ.h new file mode 100644 index 0000000..e07e40c --- /dev/null +++ b/OCI/include/occiAQ.h @@ -0,0 +1,374 @@ +/* Copyright (c) 2002, 2005, Oracle. All rights reserved. */ + +/* + NAME + occiAQ.h - Header file for occi AQ classes + + DESCRIPTION + Class declarations for Producer, Consumer, Message, Agent + Listener, Subscription + + RELATED DOCUMENTS + + + EXPORT FUNCTION(S) + + + INTERNAL FUNCTION(S) + + + EXAMPLES + + NOTES + + + MODIFIED (MM/DD/YY) + cparampa 10/12/02 - creation + +*/ + +#ifndef _olint /* disable olint check */ + +#ifndef OCCIAQ_ORACLE +# define OCCIAQ_ORACLE + +#ifndef OCCICOMMON_ORACLE +#include +#endif + +namespace oracle { +namespace occi { +namespace aq{ + +/*--------------------------------------------------------------------------- + PUBLIC TYPES AND CONSTANTS + ---------------------------------------------------------------------------*/ + +class Message +{ + public: + + enum MessageState + { + MSG_READY = OCI_MSG_READY, + MSG_WAITING = OCI_MSG_WAITING, + MSG_PROCESSED = OCI_MSG_PROCESSED, + MSG_EXPIRED = OCI_MSG_EXPIRED + }; + enum PayloadType + { + RAW, + ANYDATA, + OBJECT + }; + + Message( const Environment *env ); + Message( const Message& rhs); + ~Message(); + + void operator=(const Message& rhs); + int getAttemptsToDequeue() const ; + void setCorrelationId( const OCCI_STD_NAMESPACE::string& corr_id ) ; + OCCI_STD_NAMESPACE::string getCorrelationId() const ; + void setDelay( int delay ) ; + int getDelay() const ; + Date getMessageEnqueuedTime() const ; + void setExceptionQueueName( const OCCI_STD_NAMESPACE::string& queue ) ; + OCCI_STD_NAMESPACE::string getExceptionQueueName() const ; + void setExpiration( int exp ) ; + int getExpiration() const ; + MessageState getMessageState() const ; + void setPriority( int priority ) ; + int getPriority() const ; + void setRecipientList( OCCI_STD_NAMESPACE::vector& ag_list ) ; + void setSenderId( const Agent& sender ) ; + Agent getSenderId() const ; + void setOriginalMessageId( const Bytes& queue ) ; + Bytes getOriginalMessageId() const ; + void setNull(); + bool isNull() const; + + void setBytes( const Bytes& bytes); + void setObject( PObject* pobj); + void setAnyData( const AnyData& any); + + Bytes getBytes() const ; + PObject *getObject() ; + AnyData getAnyData() const ; + + PayloadType getPayloadType( ) const; + + private: + Ptr ptr; + OCIAQMsgProperties* getOCIMsgProperties() const; + Message( const Environment *env, const Connection *con, + OCIAQMsgProperties *msgprop, void *data, unsigned int dataLen, + bool isNull, PayloadType pType); + friend class ConsumerImpl; + friend class ProducerImpl; + friend class NotifyResult; +}; + +class Producer +{ + public: + + enum EnqueueSequence + { + ENQ_BEFORE = OCI_ENQ_BEFORE, + ENQ_TOP = OCI_ENQ_TOP + }; + enum Visibility + { + ENQ_IMMEDIATE = OCI_ENQ_IMMEDIATE, + ENQ_ON_COMMIT = OCI_ENQ_ON_COMMIT + }; + + Producer( const Connection *conn ); + Producer( const Connection *conn, + const OCCI_STD_NAMESPACE::string& queue ); + Producer( const Producer& rhs); + ~Producer(); + + void operator=(const Producer& prod); + void setRelativeMessageId( const Bytes& msgid ); + Bytes getRelativeMessageId() const; + void setSequenceDeviation( EnqueueSequence option ); + EnqueueSequence getSequenceDeviation() const; + void setVisibility( Visibility option ); + Visibility getVisibility() const; + void setQueueName( const OCCI_STD_NAMESPACE::string& queue ); + OCCI_STD_NAMESPACE::string getQueueName() const; + void setTransformation( const OCCI_STD_NAMESPACE::string& fName); + OCCI_STD_NAMESPACE::string getTransformation() const; + Bytes send( Message& msg, const OCCI_STD_NAMESPACE::string& queue ); + Bytes send( Message& msg ); + void setNull(); + bool isNull() const; + + private: + Ptr ptr; +}; + +class Consumer +{ + public: + + enum DequeueMode + { + DEQ_BROWSE = OCI_DEQ_BROWSE, + DEQ_LOCKED = OCI_DEQ_LOCKED, + DEQ_REMOVE = OCI_DEQ_REMOVE, + DEQ_REMOVE_NODATA = OCI_DEQ_REMOVE_NODATA + }; + enum Navigation + { + DEQ_FIRST_MSG = OCI_DEQ_FIRST_MSG, + DEQ_NEXT_TRANSACTION = OCI_DEQ_NEXT_TRANSACTION, + DEQ_NEXT_MSG = OCI_DEQ_NEXT_MSG + }; + enum Visibility + { + DEQ_IMMEDIATE = OCI_DEQ_IMMEDIATE, + DEQ_ON_COMMIT = OCI_DEQ_ON_COMMIT + }; + enum + { + DEQ_WAIT_FOREVER = OCI_DEQ_WAIT_FOREVER, + DEQ_NO_WAIT = OCI_DEQ_NO_WAIT + }; + + Consumer( const Connection *conn ); + Consumer( const Connection * conn, const Agent& agent); + Consumer( const Connection *conn, + const OCCI_STD_NAMESPACE::string& queue ); + Consumer(const Consumer& con); + ~Consumer(); + + void operator=(const Consumer& con); + void setAgent(const Agent& agent); + void setConsumerName( const OCCI_STD_NAMESPACE::string& name ); + OCCI_STD_NAMESPACE::string getConsumerName() const; + void setCorrelationId( const OCCI_STD_NAMESPACE::string& cor_id ); + OCCI_STD_NAMESPACE::string getCorrelationId() const; + void setDequeueMode( DequeueMode mode ); + DequeueMode getDequeueMode() const; + void setMessageIdToDequeue( const Bytes& msgid ); + Bytes getMessageIdToDequeue() const; + void setPositionOfMessage( Navigation pos ); + Navigation getPositionOfMessage() const; + void setVisibility( Visibility option ); + Visibility getVisibility() const; + void setWaitTime( unsigned int wait ); + unsigned int getWaitTime() const; + void setQueueName( const OCCI_STD_NAMESPACE::string& queue ); + OCCI_STD_NAMESPACE::string getQueueName() const; + void setTransformation( const OCCI_STD_NAMESPACE::string& fName); + OCCI_STD_NAMESPACE::string getTransformation() const; + Message receive( Message::PayloadType pType, + const OCCI_STD_NAMESPACE::string& type="", + const OCCI_STD_NAMESPACE::string& schema=""); + void setNull(); + bool isNull() const; + + private: + Ptr ptr; +}; + +class Agent +{ + public: + Agent( const Environment *env ); + Agent( const Environment *env, + const OCCI_STD_NAMESPACE::string& name, + const OCCI_STD_NAMESPACE::string& address, + unsigned int protocol=0 ) ; + Agent(const Agent& a); + ~Agent() ; + + void operator=(const Agent& a); + void setName( const OCCI_STD_NAMESPACE::string& name ); + OCCI_STD_NAMESPACE::string getName() const; + void setAddress( const OCCI_STD_NAMESPACE::string& addr ); + OCCI_STD_NAMESPACE::string getAddress() const; + void setProtocol(unsigned int protocol = 0); + unsigned int getProtocol() const; + void setNull(); + bool isNull() const; + OCIAQAgent* getOCIAQAgent() const; + + private: + Ptr ptr; + Agent( const Environment *env, OCIAQAgent *rhs, bool toFree = false ); + friend class Listener; + friend class MessageImpl; +}; + +class Listener +{ + public: + Listener( const Connection *conn ); + Listener( const Connection *conn, + OCCI_STD_NAMESPACE::vector &agList, + int waitTime=0 ); + ~Listener(); + + Agent listen(); + void setAgentList(OCCI_STD_NAMESPACE::vector &agList); + void setTimeOutForListen(int waitTime); + OCCI_STD_NAMESPACE::vector getAgentList() const; + int getTimeOutForListen() const; + + private: + const ConnectionImpl *conn; + OCIAQAgent** agentList; + unsigned int numAgents; + int timeOut; + void *listenerExt; +}; + + +class Subscription +{ + public: + enum Presentation + { + PRES_DEFAULT = OCI_SUBSCR_PRES_DEFAULT, + PRES_XML = OCI_SUBSCR_PRES_XML + }; + enum Protocol + { + PROTO_CBK = OCI_SUBSCR_PROTO_OCI, + PROTO_MAIL = OCI_SUBSCR_PROTO_MAIL, + PROTO_SERVER = OCI_SUBSCR_PROTO_SERVER, + PROTO_HTTP = OCI_SUBSCR_PROTO_HTTP + }; + enum Namespace + { + NS_ANONYMOUS = OCI_SUBSCR_NAMESPACE_ANONYMOUS, + NS_AQ = OCI_SUBSCR_NAMESPACE_AQ + }; + + Subscription(const Environment* env); + Subscription(const Environment* env, OCISubscription* sub); + Subscription(const Subscription& sub); + ~Subscription(); + + void operator=(const Subscription& sub); + unsigned int getDatabaseServersCount() const; + void setDatabaseServerNames( + const OCCI_STD_NAMESPACE::vector& dbsrv); + OCCI_STD_NAMESPACE::vector + getDatabaseServerNames() const ; + void setNotifyCallback(unsigned int (*callback)(Subscription& sub, + NotifyResult *nr)); + unsigned int (*getNotifyCallback() const)(Subscription& sub, + NotifyResult *nr); + void setCallbackContext(void* ctx); + void* getCallbackContext() const; + void setSubscriptionName(const OCCI_STD_NAMESPACE::string& name); + OCCI_STD_NAMESPACE::string getSubscriptionName() const ; + void setSubscriptionNamespace(Namespace nameSpace); + Namespace getSubscriptionNamespace() const ; + void setPayload(const Bytes& payload); + Bytes getPayload() const ; + void setRecipientName( const OCCI_STD_NAMESPACE::string& name); + OCCI_STD_NAMESPACE::string getRecipientName() const; + void setPresentation( Presentation pres) ; + Presentation getPresentation() const ; + void setProtocol( Protocol prot) ; + Protocol getProtocol() const ; + OCISubscription* getOCISubscription() const; + void setNull(); + bool isNull() const; + Environment* getEnvironment() const; + + private: + Ptr ptr; +}; + +class NotifyResult +{ + public: + Bytes getPayload() const; + Message getMessage() const; + Bytes getMessageId() const; + OCCI_STD_NAMESPACE::string getConsumerName() const; + OCCI_STD_NAMESPACE::string getQueueName() const; + + private: + const EnvironmentImpl *env; + void *payload; + unsigned int payloadLen; + void *desc; + ub4 mode; + void *notifyResultExt; + + //private constructor + NotifyResult(const Environment *env, void *payload, ub4 payloadLen, + void *pdescriptor, ub4 mode); + + friend class SubscriptionImpl; +}; + +/*--------------------------------------------------------------------------- + PRIVATE TYPES AND CONSTANTS + ---------------------------------------------------------------------------*/ + + +/*--------------------------------------------------------------------------- + EXPORT FUNCTIONS + ---------------------------------------------------------------------------*/ + + +/*--------------------------------------------------------------------------- + INTERNAL FUNCTIONS + ---------------------------------------------------------------------------*/ +} /* end of namespace aq */ +} /* end of namespace occi */ +} /* end of namespace oracle */ + +#endif /* OCCIAQ_ORACLE */ + +#endif /* _olint */ diff --git a/OCI/include/occiCommon.h b/OCI/include/occiCommon.h new file mode 100644 index 0000000..5485ff0 --- /dev/null +++ b/OCI/include/occiCommon.h @@ -0,0 +1,982 @@ +/* Copyright (c) 2000, 2008, Oracle. All rights reserved. */ + +/* + NAME + occiCommon.h - header file for doing forward references + + DESCRIPTION + Just declare all the classes + + RELATED DOCUMENTS + OCCI Programmer's Guide + + EXPORT FUNCTION(S) + none + + INTERNAL FUNCTION(S) + none + + EXAMPLES + + NOTES + none + +*/ + + +#ifndef OCCICOMMON_ORACLE +# define OCCICOMMON_ORACLE + +#ifndef _olint + +#ifndef OCI_ORACLE +#include +#endif + +#ifndef ORASTRINGSTL +#define ORASTRINGSTL +#include +#endif + +#ifndef ORAVECTORSTL +#include +#define ORAVECTORSTL +#endif + +#ifndef ORALISTSTL +#include +#define ORALISTSTL +#endif + +#define OCCI_STD_NAMESPACE std +#define OCCI_HAVE_STD_NAMESPACE 1 + +// version definitions +#define OCCI_MAJOR_VERSION OCI_MAJOR_VERSION +#define OCCI_MINOR_VERSION OCI_MINOR_VERSION + +namespace oracle { +namespace occi { + +//UString is the class for UTF16 characterset +//check for version = 3.2 or 3.3 +#if (__GNUC__ == 3 && (__GNUC_MINOR__ == 2 || __GNUC_MINOR__ == 3)) + //char_traits specialization for utext for gcc 3.2.3 + struct utext_char_traits + { + typedef utext char_type; + typedef unsigned int int_type; + + typedef OCCI_STD_NAMESPACE::streampos pos_type; + typedef OCCI_STD_NAMESPACE::streamoff off_type; + typedef OCCI_STD_NAMESPACE::mbstate_t state_type; + + //assign one char to another + static void assign(char_type& c1, const char_type& c2) + { + c1 = c2; + } + + //are 2 chars equal ? + static bool eq(const char_type& c1, const char_type& c2) + { + return c1 == c2; + } + + //is char c1 less then c2 ? + static bool lt(const char_type& c1, const char_type& c2) + { + return c1 < c2; + } + + //compare 2 strings of char + static int compare(const char_type* s1, const char_type* s2, size_t n) + { + for (size_t i = 0; i < n; ++i) + if (!eq(s1[i], s2[i])) + return s1[i] < s2[i] ? -1 : 1; + return 0; + } + + //length of a char string + static size_t length(const char_type* s) + { + const char_type nullchar = char_type(0); + size_t i = 0; + + while (!eq(*s++, nullchar)) i++; + return i; + } + + //find a character in the char string + static const char_type* find(const char_type* s, + size_t n, const char_type& c) + { + for ( ; n > 0 ; ++s, --n) + if (eq(*s, c)) + return s; + return 0; + } + + //move n chars from s2 to s1 + static char_type* move(char_type* s1, const char_type* s2, size_t n) + { + memmove(s1, s2, n * sizeof(char_type)); + return s1; + } + + //copy n chars from s2 to s1 + static char_type* copy(char_type* s1, const char_type* s2, size_t n) + { + memcpy(s1, s2, n * sizeof(char_type)); + return s1; + } + + //fill char c into s + static char_type* assign(char_type* s, size_t n, char_type c) + { + for (size_t i = 0; i < n; ++i) + assign(s[i], c); + return s; + } + + //is the int representation eof ? + static int_type not_eof(const int_type& c) + { + if (c == eof()) + return 0; + else + return c; + } + + //cast a int type to char + static char_type to_char_type(const int_type& c) + { + return static_cast(c); + } + + //cast char to int type + static int_type to_int_type(const char_type& c) + { + return static_cast(c); + } + + //eq operator when the chars are represented as ints + static bool eq_int_type(const int_type& c1, const int_type& c2) + { + return c1 == c2; + } + + //eof character + static int_type eof() + { + return static_cast(-1); + } + + + }; //end char_traits + +typedef OCCI_STD_NAMESPACE::basic_string UString; +#else +//for non gcc 3.2.3 platforms +typedef OCCI_STD_NAMESPACE::basic_string UString; +#endif /* if gcc 3.2.3 */ + +class Environment; +class EnvironmentImpl; +class Connection; +class ConnectionImpl; +class ConnectionPool; +class ConnectionPoolImpl; +class StatelessConnectionPool; +class StatelessConnectionPoolImpl; +class Statement; +class StatementImpl; +class ResultSet; +class ResultSetImpl; +class SQLException; +class SQLExceptionImpl; +class BatchSQLException; +class BatchSQLExceptionImpl; +class Stream; +class PObject; +class Number; +class Bytes; +class BytesImpl; +class Date; +class Timestamp; + +class MetaData; +class MetaDataImpl; +template class Ref; +class RefImpl; +class RefAny; +class Blob; +class Bfile; +class Clob; +class LobStreamImpl; +class AnyData; +class AnyDataImpl; +class Map; +class IntervalDS; +class IntervalYM; + +namespace aq { +class Message; +class MessageImpl; +class Agent; +class AgentImpl; +class Producer; +class ProducerImpl; +class Consumer; +class ConsumerImpl; +class Listener; +class Subscription; +class SubscriptionImpl; +class NotifyResult; +} + +typedef struct BFloat BFloat; +typedef struct BDouble BDouble; + +/*--------------------------------------------------------------------------- + ENUMERATORS + ---------------------------------------------------------------------------*/ +enum Type +{ + OCCI_SQLT_CHR=SQLT_CHR, + OCCI_SQLT_NUM=SQLT_NUM, + OCCIINT = SQLT_INT, + OCCIFLOAT = SQLT_FLT, + OCCIBFLOAT = SQLT_BFLOAT, + OCCIBDOUBLE = SQLT_BDOUBLE, + OCCIIBFLOAT = SQLT_IBFLOAT, + OCCIIBDOUBLE = SQLT_IBDOUBLE, + OCCI_SQLT_STR=SQLT_STR, + OCCI_SQLT_VNU=SQLT_VNU, + OCCI_SQLT_PDN=SQLT_PDN, + OCCI_SQLT_LNG=SQLT_LNG, + OCCI_SQLT_VCS=SQLT_VCS, + OCCI_SQLT_NON=SQLT_NON, + OCCI_SQLT_RID=SQLT_RID, + OCCI_SQLT_DAT=SQLT_DAT, + OCCI_SQLT_VBI=SQLT_VBI, + OCCI_SQLT_BIN=SQLT_BIN, + OCCI_SQLT_LBI=SQLT_LBI, + OCCIUNSIGNED_INT = SQLT_UIN, + OCCI_SQLT_SLS=SQLT_SLS, + OCCI_SQLT_LVC=SQLT_LVC, + OCCI_SQLT_LVB=SQLT_LVB, + OCCI_SQLT_AFC=SQLT_AFC, + OCCI_SQLT_AVC=SQLT_AVC, + OCCI_SQLT_CUR=SQLT_CUR, + OCCI_SQLT_RDD=SQLT_RDD, + OCCI_SQLT_LAB=SQLT_LAB, + OCCI_SQLT_OSL=SQLT_OSL, + OCCI_SQLT_NTY=SQLT_NTY, + OCCI_SQLT_REF=SQLT_REF, + OCCI_SQLT_CLOB=SQLT_CLOB, + OCCI_SQLT_BLOB=SQLT_BLOB, + OCCI_SQLT_BFILEE=SQLT_BFILEE, + OCCI_SQLT_CFILEE=SQLT_CFILEE, + OCCI_SQLT_RSET=SQLT_RSET, + OCCI_SQLT_NCO=SQLT_NCO, + OCCI_SQLT_VST=SQLT_VST, + OCCI_SQLT_ODT=SQLT_ODT, + OCCI_SQLT_DATE=SQLT_DATE, + OCCI_SQLT_TIME=SQLT_TIME, + OCCI_SQLT_TIME_TZ=SQLT_TIME_TZ, + OCCI_SQLT_TIMESTAMP=SQLT_TIMESTAMP, + OCCI_SQLT_TIMESTAMP_TZ=SQLT_TIMESTAMP_TZ, + OCCI_SQLT_INTERVAL_YM=SQLT_INTERVAL_YM, + OCCI_SQLT_INTERVAL_DS=SQLT_INTERVAL_DS, + OCCI_SQLT_TIMESTAMP_LTZ=SQLT_TIMESTAMP_LTZ, + OCCI_SQLT_FILE=SQLT_FILE, + OCCI_SQLT_CFILE=SQLT_CFILE, + OCCI_SQLT_BFILE=SQLT_BFILE, + + OCCICHAR = 32 *1024, + OCCIDOUBLE, + OCCIBOOL, + OCCIANYDATA , + OCCINUMBER, + OCCIBLOB, + OCCIBFILE, + OCCIBYTES, + OCCICLOB , + OCCIVECTOR, + OCCIMETADATA, + OCCIPOBJECT, + OCCIREF , + OCCIREFANY, + OCCISTRING , + OCCISTREAM , + OCCIDATE , + OCCIINTERVALDS , + OCCIINTERVALYM , + OCCITIMESTAMP, + OCCIROWID, + OCCICURSOR + + +}; + +enum LockOptions {OCCI_LOCK_NONE = OCI_LOCK_NONE, + OCCI_LOCK_X = OCI_LOCK_X, + OCCI_LOCK_X_NOWAIT = OCI_LOCK_X_NOWAIT + }; + +enum {OCCI_MAX_PREFETCH_DEPTH = UB4MAXVAL}; + +enum TypeCode +{ + +OCCI_TYPECODE_REF = OCI_TYPECODE_REF, +OCCI_TYPECODE_DATE = OCI_TYPECODE_DATE, +OCCI_TYPECODE_REAL = OCI_TYPECODE_REAL, +OCCI_TYPECODE_DOUBLE = OCI_TYPECODE_DOUBLE, +OCCI_TYPECODE_BDOUBLE = OCI_TYPECODE_BDOUBLE, +OCCI_TYPECODE_FLOAT = OCI_TYPECODE_FLOAT, +OCCI_TYPECODE_BFLOAT = OCI_TYPECODE_BFLOAT, +OCCI_TYPECODE_NUMBER = OCI_TYPECODE_NUMBER, +OCCI_TYPECODE_DECIMAL = OCI_TYPECODE_DECIMAL, +OCCI_TYPECODE_OCTET = OCI_TYPECODE_OCTET, +OCCI_TYPECODE_INTEGER = OCI_TYPECODE_INTEGER, +OCCI_TYPECODE_SMALLINT= OCI_TYPECODE_SMALLINT, +OCCI_TYPECODE_RAW = OCI_TYPECODE_RAW, +OCCI_TYPECODE_VARCHAR2 = OCI_TYPECODE_VARCHAR2, +OCCI_TYPECODE_VARCHAR = OCI_TYPECODE_VARCHAR, +OCCI_TYPECODE_CHAR = OCI_TYPECODE_CHAR, +OCCI_TYPECODE_VARRAY= OCI_TYPECODE_VARRAY, +OCCI_TYPECODE_TABLE = OCI_TYPECODE_TABLE, +OCCI_TYPECODE_CLOB = OCI_TYPECODE_CLOB, +OCCI_TYPECODE_BLOB = OCI_TYPECODE_BLOB, +OCCI_TYPECODE_BFILE = OCI_TYPECODE_BFILE, +OCCI_TYPECODE_OBJECT = OCI_TYPECODE_OBJECT, +OCCI_TYPECODE_NAMEDCOLLECTION = OCI_TYPECODE_NAMEDCOLLECTION +}; + +enum CharSetForm +{ + OCCI_SQLCS_IMPLICIT = SQLCS_IMPLICIT // use local db char set + ,OCCI_SQLCS_NCHAR = SQLCS_NCHAR // use local db nchar set + ,OCCI_SQLCS_EXPLICIT = SQLCS_EXPLICIT // char set explicitly specified + ,OCCI_SQLCS_FLEXIBLE = SQLCS_FLEXIBLE // pl/sql flexible parameter +}; + +enum LobOpenMode +{ OCCI_LOB_READONLY = OCI_LOB_READONLY + ,OCCI_LOB_READWRITE = OCI_LOB_READWRITE + ,OCCI_LOB_WRITEONLY = OCI_LOB_WRITEONLY + ,OCCI_LOB_APPENDONLY = OCI_LOB_APPENDONLY + ,OCCI_LOB_FULLOVERWRITE = OCI_LOB_FULLOVERWRITE + ,OCCI_LOB_FULLREAD = OCI_LOB_FULLREAD +}; + +enum LobOptionType +{ + OCCI_LOB_OPT_NONE = 0, + OCCI_LOB_OPT_COMPRESS = OCI_LOB_OPT_COMPRESS, + OCCI_LOB_OPT_ENCRYPT = OCI_LOB_OPT_ENCRYPT, + OCCI_LOB_OPT_DEDUPLICATE = OCI_LOB_OPT_DEDUPLICATE, + OCCI_LOB_OPT_ALLOCSIZE = OCI_LOB_OPT_ALLOCSIZE, + OCCI_LOB_OPT_CONTENTTYPE = OCI_LOB_OPT_CONTENTTYPE, + OCCI_LOB_OPT_MODTIME = OCI_LOB_OPT_MODTIME +}; + +enum LobOptionValue +{ + // Compression Options + OCCI_LOB_COMPRESS_OFF = OCI_LOB_COMPRESS_OFF, + OCCI_LOB_COMPRESS_ON = OCI_LOB_COMPRESS_ON, + // Encryption Options + OCCI_LOB_ENCRYPT_OFF = OCI_LOB_ENCRYPT_OFF, + OCCI_LOB_ENCRYPT_ON = OCI_LOB_ENCRYPT_ON, + // Sharing Options + OCCI_LOB_DEDUPLICATE_OFF = OCI_LOB_DEDUPLICATE_OFF, + OCCI_LOB_DEDUPLICATE_ON = OCI_LOB_DEDUPLICATE_ON +}; + +class RefCounted { +public: + RefCounted(); + virtual ~RefCounted(){} + const RefCounted * newRef() const; + void deleteRef() const; + +private: + + void onZeroReferences(); + unsigned long references_; + }; + +template +class ConstPtr +{ + +public: + +ConstPtr( const T* ptr = 0 ); +ConstPtr( const ConstPtr& mp ); +~ConstPtr(); +const T * operator->() const; +const T* rawPtr() const; + +#ifdef MEMBER_TEMPLATE +template operator ConstPtr(); +#endif + +protected: + +void operator=( const ConstPtr& mp ); +const T* rawPtr_; + +}; + +template +class Ptr : public ConstPtr { + +public: + +Ptr( T* ptr = 0 ); +Ptr( const Ptr& mp ); +void operator=( const Ptr& mp ); +const T * operator->() const; +T * operator->(); +T* rawPtr() ; +const T* rawPtr() const; + + + +#ifdef MEMBER_TEMPLATE + template + operator Ptr(); +#endif + +}; + +/*--------------------------------------------------------------------------- + EXPORT FUNCTIONS + ---------------------------------------------------------------------------*/ + + void getVector(const AnyData &any, + OCCI_STD_NAMESPACE::vector &vect); + void getVector(const AnyData &any, + OCCI_STD_NAMESPACE::vector &vect); + void getVector( const AnyData &any, + OCCI_STD_NAMESPACE::vector &vect) ; + void getVector( const AnyData &any, + OCCI_STD_NAMESPACE::vector &vect) ; + void getVector( const AnyData &any, + OCCI_STD_NAMESPACE::vector &vect) ; + void getVector( const AnyData &any, + OCCI_STD_NAMESPACE::vector &vect) ; + void getVector( const AnyData &any, + OCCI_STD_NAMESPACE::vector &vect); + void getVector(const AnyData &any, + OCCI_STD_NAMESPACE::vector &vect); + void getVector( const AnyData &any, + OCCI_STD_NAMESPACE::vector &vect) ; + void getVector( const AnyData &any, + OCCI_STD_NAMESPACE::vector &vect) ; + void getVector( const AnyData &any, + OCCI_STD_NAMESPACE::vector &vect) ; + void getVector( const AnyData &any, + OCCI_STD_NAMESPACE::vector &vect) ; + void getVector( const AnyData &any, + OCCI_STD_NAMESPACE::vector &vect) ; + template + void getVectorOfRefs( const AnyData &any, + OCCI_STD_NAMESPACE::vector< Ref > &vect) ; + + #if !defined(WIN32COMMON) && !defined(__MVS__) + template + void getVector(const AnyData &any, + OCCI_STD_NAMESPACE::vector< Ref > &vect) ; + #endif + #if defined(WIN32COMMON) || defined(__MVS__) + template + void getVector(const AnyData &any, + OCCI_STD_NAMESPACE::vector &vect, + void *(*rSQL)(void *)); + #else + template + void getVector(const AnyData &any, + OCCI_STD_NAMESPACE::vector &vect, + void *(*rSQL)(void *)); + #endif + + void setVector( AnyData &any, + const OCCI_STD_NAMESPACE::vector &vect) ; + void setVector( AnyData &any, + const OCCI_STD_NAMESPACE::vector &vect) ; + void setVector( AnyData &any, + const OCCI_STD_NAMESPACE::vector &vect) ; + void setVector( AnyData &any, + const OCCI_STD_NAMESPACE::vector &vect) ; + void setVector( AnyData &any, + const OCCI_STD_NAMESPACE::vector &vect) ; + void setVector( AnyData &any, + const OCCI_STD_NAMESPACE::vector &vect) ; + void setVector( AnyData &any, + const OCCI_STD_NAMESPACE::vector &vect) ; + void setVector( AnyData &any, + const OCCI_STD_NAMESPACE::vector &vect) ; + void setVector( AnyData &any, + const OCCI_STD_NAMESPACE::vector &vect) ; + void setVector( AnyData &any, + const OCCI_STD_NAMESPACE::vector &vect) ; + void setVector( AnyData &any, + const OCCI_STD_NAMESPACE::vector &vect) ; + void setVector( AnyData &any, + const OCCI_STD_NAMESPACE::vector &vect) ; + void setVector( AnyData &any, + const OCCI_STD_NAMESPACE::vector &vect) ; + template + void setVectorOfRefs( AnyData &any, + const OCCI_STD_NAMESPACE::vector< Ref > &vect) ; + #if !defined(WIN32COMMON) && !defined(__MVS__) + template + void setVector( AnyData &any, + const OCCI_STD_NAMESPACE::vector< Ref > &vect) ; + #endif + #if defined(WIN32COMMON) || defined(__MVS__) + template + void setVector( AnyData &any, + const OCCI_STD_NAMESPACE::vector< T > &vect) ; + #else + template + void setVector( AnyData &any, + const OCCI_STD_NAMESPACE::vector< T* > &vect) ; + #endif + + void getVector( ResultSet *rs, unsigned int index, + OCCI_STD_NAMESPACE::vector &vect) ; + void getVector( ResultSet *rs, unsigned int index, + OCCI_STD_NAMESPACE::vector &vect) ; + void getVector( ResultSet *rs, unsigned int index, + OCCI_STD_NAMESPACE::vector &vect) ;//UTF16 support + void getVector(ResultSet *rs, unsigned int, + OCCI_STD_NAMESPACE::vector &vect) ; + void getVector(ResultSet *rs, unsigned int, + OCCI_STD_NAMESPACE::vector &vect); + void getVector(ResultSet *rs, unsigned int, + OCCI_STD_NAMESPACE::vector &vect); + void getVector(ResultSet *rs, unsigned int, + OCCI_STD_NAMESPACE::vector &vect); + void getVector(ResultSet *rs, unsigned int, + OCCI_STD_NAMESPACE::vector &vect); + void getVector(ResultSet *rs, unsigned int, + OCCI_STD_NAMESPACE::vector &vect) ; + void getVector(ResultSet *rs, unsigned int, + OCCI_STD_NAMESPACE::vector &vect) ; + void getVector(ResultSet *rs, unsigned int, + OCCI_STD_NAMESPACE::vector &vect) ; + void getVector(ResultSet *rs, unsigned int, + OCCI_STD_NAMESPACE::vector &vect) ; + void getVector(ResultSet *rs, unsigned int, + OCCI_STD_NAMESPACE::vector &vect) ; + void getVector(ResultSet *rs, unsigned int, + OCCI_STD_NAMESPACE::vector &vect) ; + void getVector(ResultSet *rs, unsigned int, + OCCI_STD_NAMESPACE::vector &vect) ; + void getVector(ResultSet *rs, unsigned int, + OCCI_STD_NAMESPACE::vector &vect) ; + void getVector(ResultSet *rs, unsigned int, + OCCI_STD_NAMESPACE::vector &vect) ; + template + void getVectorOfRefs(ResultSet *rs, unsigned int, + OCCI_STD_NAMESPACE::vector > &vect) ; + #if !defined(WIN32COMMON) && !defined(__MVS__) + template + void getVector(ResultSet *rs, unsigned int, + OCCI_STD_NAMESPACE::vector > &vect) ; + #endif + #if defined(WIN32COMMON) || defined(__MVS__) + template + void getVector( ResultSet *rs, unsigned int index, + OCCI_STD_NAMESPACE::vector< T > &vect) ; + #else + template + void getVector( ResultSet *rs, unsigned int index, + OCCI_STD_NAMESPACE::vector< T* > &vect) ; + #endif + + + void getVector(Statement *rs, unsigned int, + OCCI_STD_NAMESPACE::vector &vect) ; + void getVector(Statement *rs, unsigned int, + OCCI_STD_NAMESPACE::vector &vect) ; + void getVector(Statement *rs, unsigned int, + OCCI_STD_NAMESPACE::vector &vect) ; + void getVector(Statement *rs, unsigned int, + OCCI_STD_NAMESPACE::vector &vect) ; + void getVector(Statement *rs, unsigned int, + OCCI_STD_NAMESPACE::vector &vect) ; + void getVector(Statement *rs, unsigned int, + OCCI_STD_NAMESPACE::vector &vect) ; + void getVector(Statement *rs, unsigned int, + OCCI_STD_NAMESPACE::vector &vect) ; + void getVector( Statement *rs, unsigned int index, + OCCI_STD_NAMESPACE::vector &vect) ; + void getVector( Statement *rs, unsigned int index, + OCCI_STD_NAMESPACE::vector &vect) ; + void getVector( Statement *rs, unsigned int index, + OCCI_STD_NAMESPACE::vector &vect) ;//UTF16 support + void getVector(Statement *rs, unsigned int, + OCCI_STD_NAMESPACE::vector &vect) ; + void getVector(Statement *rs, unsigned int, + OCCI_STD_NAMESPACE::vector &vect) ; + void getVector(Statement *rs, unsigned int, + OCCI_STD_NAMESPACE::vector &vect) ; + void getVector(Statement *rs, unsigned int, + OCCI_STD_NAMESPACE::vector &vect) ; + void getVector(Statement *rs, unsigned int, + OCCI_STD_NAMESPACE::vector &vect) ; + void getVector(Statement *rs, unsigned int, + OCCI_STD_NAMESPACE::vector &vect) ; + void getVector(Statement *rs, unsigned int, + OCCI_STD_NAMESPACE::vector &vect) ; + template + void getVectorOfRefs(Statement *rs, unsigned int, + OCCI_STD_NAMESPACE::vector > &vect) ; + #if !defined(WIN32COMMON) && !defined(__MVS__) + template + void getVector(Statement *rs, unsigned int, + OCCI_STD_NAMESPACE::vector > &vect) ; + #endif + #if defined(WIN32COMMON) || defined(__MVS__) + template + void getVector( Statement *rs, unsigned int index, + OCCI_STD_NAMESPACE::vector< T > &vect) ; + #else + template + void getVector( Statement *rs, unsigned int index, + OCCI_STD_NAMESPACE::vector< T* > &vect) ; + #endif + + + void setVector(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const OCCI_STD_NAMESPACE::string &sqltype) ; + void setVector(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const OCCI_STD_NAMESPACE::string &sqltype) ; + void setVector(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const OCCI_STD_NAMESPACE::string &sqltype) ; + void setVector(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const OCCI_STD_NAMESPACE::string &sqltype) ; + void setVector(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const OCCI_STD_NAMESPACE::string &sqltype) ; + void setVector(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const OCCI_STD_NAMESPACE::string &sqltype) ; + void setVector(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const OCCI_STD_NAMESPACE::string &sqltype); + void setVector(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const OCCI_STD_NAMESPACE::string &sqltype) ; + void setVector(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const OCCI_STD_NAMESPACE::string &sqltype) ; + void setVector(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const OCCI_STD_NAMESPACE::string &sqltype) ; + void setVector(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const OCCI_STD_NAMESPACE::string &sqltype) ; + void setVector(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const OCCI_STD_NAMESPACE::string &sqltype) ; + void setVector(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const OCCI_STD_NAMESPACE::string &sqltype) ; + void setVector(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const OCCI_STD_NAMESPACE::string &sqltype) ; + void setVector(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const OCCI_STD_NAMESPACE::string &sqltype) ; + void setVector(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const OCCI_STD_NAMESPACE::string &sqltype) ; + template + void setVectorOfRefs(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector > &vect, + const OCCI_STD_NAMESPACE::string &sqltype) ; + #if !defined(WIN32COMMON) && !defined(__MVS__) + template + void setVector(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector > &vect, + const OCCI_STD_NAMESPACE::string &sqltype) ; + #endif + #if defined(WIN32COMMON) || defined(__MVS__) + template + void setVector( Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector< T > &vect, + const OCCI_STD_NAMESPACE::string &sqltype) ; + #else + template + void setVector( Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const OCCI_STD_NAMESPACE::string &sqltype) ; + #endif + +/* ------------------------------------------------------------------------ + Statement setVector functions, schema & type separate + arguments - multibyte support + ------------------------------------------------------------------------ +*/ + void setVector(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const OCCI_STD_NAMESPACE::string &schemaName, + const OCCI_STD_NAMESPACE::string &typeName) ; + void setVector(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const OCCI_STD_NAMESPACE::string &schemaName, + const OCCI_STD_NAMESPACE::string &typeName) ; + void setVector(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const OCCI_STD_NAMESPACE::string &schemaName, + const OCCI_STD_NAMESPACE::string &typeName) ; + void setVector(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const OCCI_STD_NAMESPACE::string &schemaName, + const OCCI_STD_NAMESPACE::string &typeName) ; + void setVector(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const OCCI_STD_NAMESPACE::string &schemaName, + const OCCI_STD_NAMESPACE::string &typeName) ; + void setVector(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const OCCI_STD_NAMESPACE::string &schemaName, + const OCCI_STD_NAMESPACE::string &typeName) ; + void setVector(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const OCCI_STD_NAMESPACE::string &schemaName, + const OCCI_STD_NAMESPACE::string &typeName); + void setVector(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const OCCI_STD_NAMESPACE::string &schemaName, + const OCCI_STD_NAMESPACE::string &typeName) ; + void setVector(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const OCCI_STD_NAMESPACE::string &schemaName, + const OCCI_STD_NAMESPACE::string &typeName) ; + void setVector(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const OCCI_STD_NAMESPACE::string &schemaName, + const OCCI_STD_NAMESPACE::string &typeName) ; + void setVector(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const OCCI_STD_NAMESPACE::string &schemaName, + const OCCI_STD_NAMESPACE::string &typeName) ; + void setVector(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const OCCI_STD_NAMESPACE::string &schemaName, + const OCCI_STD_NAMESPACE::string &typeName) ; + void setVector(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const OCCI_STD_NAMESPACE::string &schemaName, + const OCCI_STD_NAMESPACE::string &typeName) ; + void setVector(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const OCCI_STD_NAMESPACE::string &schemaName, + const OCCI_STD_NAMESPACE::string &typeName) ; + void setVector(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const OCCI_STD_NAMESPACE::string &schemaName, + const OCCI_STD_NAMESPACE::string &typeName) ; + void setVector(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const OCCI_STD_NAMESPACE::string &schemaName, + const OCCI_STD_NAMESPACE::string &typeName) ; + template + void setVectorOfRefs(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector > &vect, + const OCCI_STD_NAMESPACE::string &schemaName, + const OCCI_STD_NAMESPACE::string &typeName) ; + + #if !defined(WIN32COMMON) && !defined(__MVS__) + template + void setVector(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector > &vect, + const OCCI_STD_NAMESPACE::string &schemaName, + const OCCI_STD_NAMESPACE::string &typeName) ; + #endif + + #if defined(WIN32COMMON) || defined(__MVS__) + template + void setVector( Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector< T > &vect, + const OCCI_STD_NAMESPACE::string &schemaName, + const OCCI_STD_NAMESPACE::string &typeName) ; + #else + template + void setVector( Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, const OCCI_STD_NAMESPACE::string + &schemaName, const OCCI_STD_NAMESPACE::string &typeName) ; + #endif + +/*------------------------------------------------------------------------- + Statement setVector function - UTF16 support + ------------------------------------------------------------------------- +*/ + void setVector(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const UString &schemaName, + const UString &typeName) ; + void setVector(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const UString &schemaName, + const UString &typeName) ; + void setVector(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const UString &schemaName, + const UString &typeName) ; + void setVector(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const UString &schemaName, + const UString &typeName) ; + void setVector(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const UString &schemaName, + const UString &typeName) ; + void setVector(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const UString &schemaName, + const UString &typeName) ; + void setVector(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const UString &schemaName, + const UString &typeName); + void setVector(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const UString &schemaName, + const UString &typeName) ; + void setVector(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const OCCI_STD_NAMESPACE::string &schemaName, + const OCCI_STD_NAMESPACE::string &typeName) ; + void setVector(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const UString &schemaName, + const UString &typeName) ; + void setVector(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const UString &schemaName, + const UString &typeName) ; + void setVector(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const UString &schemaName, + const UString &typeName) ; + void setVector(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const UString &schemaName, + const UString &typeName) ; + void setVector(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const UString &schemaName, + const UString &typeName) ; + void setVector(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const UString &schemaName, + const UString &typeName) ; + void setVector(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const UString &schemaName, + const UString &typeName) ; + void setVector(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const UString &schemaName, + const UString &typeName) ; + template + void setVectorOfRefs(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector > &vect, + const UString &schemaName, + const UString &typeName) ; + + #if !defined(WIN32COMMON) && !defined(__MVS__) + template + void setVector(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector > &vect, + const UString &schemaName, + const UString &typeName) ; + #endif + + #if defined(WIN32COMMON) || defined(__MVS__) + template + void setVector( Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector< T > &vect, + const UString &schemaName, + const UString &typeName) ; + #else + template + void setVector( Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, const UString + &schemaName, const UString &typeName) ; + #endif + + +/* Global method for array pins */ +template +void pinVectorOfRefs( const Connection *conn, +OCCI_STD_NAMESPACE::vector > &vect, +OCCI_STD_NAMESPACE::vector &vectObj, +LockOptions lockOpt = OCCI_LOCK_NONE ); + +template +void pinVectorOfRefs( const Connection *conn, +OCCI_STD_NAMESPACE::vector > &vect, +LockOptions lockOpt = OCCI_LOCK_NONE ); + +#ifdef ORAXB8_DEFINED + void readVectorOfBfiles(const Connection *conn, + OCCI_STD_NAMESPACE::vector &vec, + oraub8 *byte_amts, oraub8 *offsets, + unsigned char *buffers[], oraub8 *buffer_lens); + + void readVectorOfBlobs(const Connection *conn, + OCCI_STD_NAMESPACE::vector &vec, + oraub8 *byte_amts, oraub8 *offsets, + unsigned char *buffers[], oraub8 *buffer_lens); + void writeVectorOfBlobs(const Connection *conn, + OCCI_STD_NAMESPACE::vector &vec, + oraub8 *byte_amts, oraub8 *offsets, + unsigned char *buffers[], oraub8 *buffer_lens); + + void readVectorOfClobs(const Connection *conn, + OCCI_STD_NAMESPACE::vector &vec, + oraub8 *byte_amts, oraub8 *char_amts, oraub8 *offsets, + unsigned char *buffers[], oraub8 *buffer_lens); + void writeVectorOfClobs(const Connection *conn, + OCCI_STD_NAMESPACE::vector &vec, + oraub8 *byte_amts, oraub8 *char_amts, oraub8 *offsets, + unsigned char *buffers[], oraub8 *buffer_lens); + void readVectorOfClobs(const Connection *conn, + OCCI_STD_NAMESPACE::vector &vec, + oraub8 *byte_amts, oraub8 *char_amts, oraub8 *offsets, + utext *buffers[], oraub8 *buffer_lens); + void writeVectorOfClobs(const Connection *conn, + OCCI_STD_NAMESPACE::vector &vec, + oraub8 *byte_amts, oraub8 *char_amts, oraub8 *offsets, + utext *buffers[], oraub8 *buffer_lens); +#endif + + +/*--------------------------------------------------------------------------- + INTERNAL FUNCTIONS + ---------------------------------------------------------------------------*/ + + +} /* end of namespace occi */ +} /* end of namespace oracle */ + + +#endif /* _olint */ + +#endif /* OCCICOMMON_ORACLE */ diff --git a/OCI/include/occiControl.h b/OCI/include/occiControl.h new file mode 100644 index 0000000..392f057 --- /dev/null +++ b/OCI/include/occiControl.h @@ -0,0 +1,2137 @@ +/* Copyright Oracle Corporation 2000, 2006. All Rights Reserved. */ + +/* + NAME + occiControl.h - header file for OCCI control classes + + DESCRIPTION + Class definitions for MetaData,SQLException,Environment, + Connection,Statement, ConnectionPool, StatelessConnectionPool + + RELATED DOCUMENTS + + + EXPORT FUNCTION(S) + + + INTERNAL FUNCTION(S) + + + EXAMPLES + + NOTES + + + +*/ + +#ifndef _olint /* disable olint check */ + +#ifndef OCCICONTROL_ORACLE +# define OCCICONTROL_ORACLE + +#ifndef OCCICOMMON_ORACLE +#include +#endif + +#ifndef ORAEXCEPTION +#define ORAEXCEPTION +#include +#endif + +namespace oracle { +namespace occi { +/*--------------------------------------------------------------------------- + PUBLIC TYPES AND CONSTANTS + ---------------------------------------------------------------------------*/ + +class MetaData +{ + public : + + enum AttrId + {ATTR_PTYPE = OCI_ATTR_PTYPE, + ATTR_TIMESTAMP = OCI_ATTR_TIMESTAMP, + ATTR_OBJ_ID = OCI_ATTR_OBJ_ID, + ATTR_OBJ_NAME = OCI_ATTR_OBJ_NAME, + ATTR_OBJ_SCHEMA = OCI_ATTR_OBJ_SCHEMA, + ATTR_OBJID = OCI_ATTR_OBJID, + ATTR_NUM_COLS = OCI_ATTR_NUM_COLS, + ATTR_LIST_COLUMNS = OCI_ATTR_LIST_COLUMNS, + ATTR_REF_TDO = OCI_ATTR_REF_TDO, + ATTR_IS_TEMPORARY = OCI_ATTR_IS_TEMPORARY, + ATTR_IS_TYPED = OCI_ATTR_IS_TYPED, + ATTR_DURATION = OCI_ATTR_DURATION, + ATTR_COLLECTION_ELEMENT = OCI_ATTR_COLLECTION_ELEMENT, + ATTR_RDBA = OCI_ATTR_RDBA, + ATTR_TABLESPACE = OCI_ATTR_TABLESPACE, + ATTR_CLUSTERED = OCI_ATTR_CLUSTERED, + ATTR_PARTITIONED = OCI_ATTR_PARTITIONED, + ATTR_INDEX_ONLY = OCI_ATTR_INDEX_ONLY, + ATTR_LIST_ARGUMENTS = OCI_ATTR_LIST_ARGUMENTS, + ATTR_IS_INVOKER_RIGHTS = OCI_ATTR_IS_INVOKER_RIGHTS, + ATTR_LIST_SUBPROGRAMS = OCI_ATTR_LIST_SUBPROGRAMS, + ATTR_NAME = OCI_ATTR_NAME, + ATTR_OVERLOAD_ID = OCI_ATTR_OVERLOAD_ID, + ATTR_TYPECODE = OCI_ATTR_TYPECODE, + ATTR_COLLECTION_TYPECODE = OCI_ATTR_COLLECTION_TYPECODE, + ATTR_VERSION = OCI_ATTR_VERSION, + ATTR_IS_INCOMPLETE_TYPE = OCI_ATTR_IS_INCOMPLETE_TYPE, + ATTR_IS_SYSTEM_TYPE = OCI_ATTR_IS_SYSTEM_TYPE, + ATTR_IS_PREDEFINED_TYPE = OCI_ATTR_IS_PREDEFINED_TYPE, + ATTR_IS_TRANSIENT_TYPE = OCI_ATTR_IS_TRANSIENT_TYPE, + ATTR_IS_SYSTEM_GENERATED_TYPE = + OCI_ATTR_IS_SYSTEM_GENERATED_TYPE, + ATTR_HAS_NESTED_TABLE = OCI_ATTR_HAS_NESTED_TABLE, + ATTR_HAS_LOB = OCI_ATTR_HAS_LOB, + ATTR_HAS_FILE = OCI_ATTR_HAS_FILE, + ATTR_NUM_TYPE_ATTRS = OCI_ATTR_NUM_TYPE_ATTRS, + ATTR_LIST_TYPE_ATTRS = OCI_ATTR_LIST_TYPE_ATTRS, + ATTR_NUM_TYPE_METHODS = OCI_ATTR_NUM_TYPE_METHODS, + ATTR_LIST_TYPE_METHODS = OCI_ATTR_LIST_TYPE_METHODS, + ATTR_MAP_METHOD = OCI_ATTR_MAP_METHOD, + ATTR_ORDER_METHOD = OCI_ATTR_ORDER_METHOD, + ATTR_DATA_SIZE = OCI_ATTR_DATA_SIZE, + ATTR_DATA_TYPE = OCI_ATTR_DATA_TYPE, + ATTR_PRECISION = OCI_ATTR_PRECISION, + ATTR_SCALE = OCI_ATTR_SCALE, + ATTR_TYPE_NAME = OCI_ATTR_TYPE_NAME, + ATTR_SCHEMA_NAME = OCI_ATTR_SCHEMA_NAME, + ATTR_CHARSET_ID = OCI_ATTR_CHARSET_ID, + ATTR_CHARSET_FORM = OCI_ATTR_CHARSET_FORM, + ATTR_ENCAPSULATION = OCI_ATTR_ENCAPSULATION, + ATTR_IS_CONSTRUCTOR = OCI_ATTR_IS_CONSTRUCTOR, + ATTR_IS_DESTRUCTOR = OCI_ATTR_IS_DESTRUCTOR, + ATTR_IS_OPERATOR = OCI_ATTR_IS_OPERATOR, + ATTR_IS_SELFISH = OCI_ATTR_IS_SELFISH, + ATTR_IS_MAP = OCI_ATTR_IS_MAP, + ATTR_IS_ORDER = OCI_ATTR_IS_ORDER, + ATTR_IS_RNDS = OCI_ATTR_IS_RNDS, + ATTR_IS_RNPS = OCI_ATTR_IS_RNPS, + ATTR_IS_WNDS = OCI_ATTR_IS_WNDS, + ATTR_IS_WNPS = OCI_ATTR_IS_WNPS, + ATTR_NUM_ELEMS = OCI_ATTR_NUM_ELEMS, + ATTR_LINK = OCI_ATTR_LINK, + ATTR_MIN = OCI_ATTR_MIN, + ATTR_MAX = OCI_ATTR_MAX, + ATTR_INCR = OCI_ATTR_INCR, + ATTR_CACHE = OCI_ATTR_CACHE, + ATTR_ORDER = OCI_ATTR_ORDER, + ATTR_HW_MARK = OCI_ATTR_HW_MARK, + ATTR_IS_NULL = OCI_ATTR_IS_NULL, + ATTR_POSITION = OCI_ATTR_POSITION, + ATTR_HAS_DEFAULT = OCI_ATTR_HAS_DEFAULT, + ATTR_LEVEL = OCI_ATTR_LEVEL, + ATTR_IOMODE = OCI_ATTR_IOMODE, + ATTR_RADIX = OCI_ATTR_RADIX, + ATTR_SUB_NAME = OCI_ATTR_SUB_NAME, + ATTR_LIST_OBJECTS = OCI_ATTR_LIST_OBJECTS, + ATTR_NCHARSET_ID = OCI_ATTR_NCHARSET_ID, + ATTR_LIST_SCHEMAS = OCI_ATTR_LIST_SCHEMAS, + ATTR_MAX_PROC_LEN = OCI_ATTR_MAX_PROC_LEN, + ATTR_MAX_COLUMN_LEN = OCI_ATTR_MAX_COLUMN_LEN, + ATTR_CURSOR_COMMIT_BEHAVIOR = + OCI_ATTR_CURSOR_COMMIT_BEHAVIOR, + ATTR_MAX_CATALOG_NAMELEN = OCI_ATTR_MAX_CATALOG_NAMELEN, + ATTR_CATALOG_LOCATION = OCI_ATTR_CATALOG_LOCATION, + ATTR_SAVEPOINT_SUPPORT = OCI_ATTR_SAVEPOINT_SUPPORT, + ATTR_NOWAIT_SUPPORT = OCI_ATTR_NOWAIT_SUPPORT, + ATTR_AUTOCOMMIT_DDL = OCI_ATTR_AUTOCOMMIT_DDL, + ATTR_LOCKING_MODE = OCI_ATTR_LOCKING_MODE, + ATTR_IS_FINAL_TYPE = OCI_ATTR_IS_FINAL_TYPE, + ATTR_IS_INSTANTIABLE_TYPE = OCI_ATTR_IS_INSTANTIABLE_TYPE, + ATTR_IS_SUBTYPE = OCI_ATTR_IS_SUBTYPE, + ATTR_SUPERTYPE_SCHEMA_NAME = OCI_ATTR_SUPERTYPE_SCHEMA_NAME, + ATTR_SUPERTYPE_NAME = OCI_ATTR_SUPERTYPE_NAME, + ATTR_FSPRECISION = OCI_ATTR_FSPRECISION, + ATTR_LFPRECISION = OCI_ATTR_LFPRECISION, + ATTR_IS_FINAL_METHOD = OCI_ATTR_IS_FINAL_METHOD, + ATTR_IS_INSTANTIABLE_METHOD = OCI_ATTR_IS_INSTANTIABLE_METHOD, + ATTR_IS_OVERRIDING_METHOD = OCI_ATTR_IS_OVERRIDING_METHOD, + ATTR_CHAR_USED = OCI_ATTR_CHAR_USED, + ATTR_CHAR_SIZE = OCI_ATTR_CHAR_SIZE, + ATTR_COL_ENC = OCI_ATTR_COL_ENC, + ATTR_COL_ENC_SALT = OCI_ATTR_COL_ENC_SALT, + ATTR_TABLE_ENC = OCI_ATTR_TABLE_ENC, + ATTR_TABLE_ENC_ALG = OCI_ATTR_TABLE_ENC_ALG, + ATTR_TABLE_ENC_ALG_ID = OCI_ATTR_TABLE_ENC_ALG_ID + }; + + enum ParamType + { + PTYPE_TABLE = OCI_PTYPE_TABLE + ,PTYPE_VIEW = OCI_PTYPE_VIEW + ,PTYPE_PROC = OCI_PTYPE_PROC + ,PTYPE_FUNC = OCI_PTYPE_FUNC + ,PTYPE_PKG = OCI_PTYPE_PKG + ,PTYPE_TYPE = OCI_PTYPE_TYPE + ,PTYPE_TYPE_ATTR = OCI_PTYPE_TYPE_ATTR + ,PTYPE_TYPE_COLL = OCI_PTYPE_TYPE_COLL + ,PTYPE_TYPE_METHOD = OCI_PTYPE_TYPE_METHOD + ,PTYPE_SYN = OCI_PTYPE_SYN + ,PTYPE_SEQ = OCI_PTYPE_SEQ + ,PTYPE_COL = OCI_PTYPE_COL + ,PTYPE_ARG = OCI_PTYPE_ARG + ,PTYPE_TYPE_ARG = OCI_PTYPE_TYPE_ARG + ,PTYPE_TYPE_RESULT = OCI_PTYPE_TYPE_RESULT + ,PTYPE_SCHEMA = OCI_PTYPE_SCHEMA + ,PTYPE_DATABASE = OCI_PTYPE_DATABASE + ,PTYPE_UNK = OCI_PTYPE_UNK + }; + + + enum { DURATION_SESSION = OCI_DURATION_SESSION + ,DURATION_TRANS = OCI_DURATION_TRANS + ,DURATION_NULL = OCI_DURATION_NULL + ,TYPEENCAP_PRIVATE = OCI_TYPEENCAP_PRIVATE + ,TYPEENCAP_PUBLIC = OCI_TYPEENCAP_PUBLIC + ,TYPEPARAM_IN = OCI_TYPEPARAM_IN + ,TYPEPARAM_OUT = OCI_TYPEPARAM_OUT + ,TYPEPARAM_INOUT = OCI_TYPEPARAM_INOUT + ,CURSOR_OPEN = OCI_CURSOR_OPEN + ,CURSOR_CLOSED = OCI_CURSOR_CLOSED + ,CL_START = OCI_CL_START + ,CL_END = OCI_CL_END + ,SP_SUPPORTED = OCI_SP_SUPPORTED + ,SP_UNSUPPORTED = OCI_SP_UNSUPPORTED + ,NW_SUPPORTED = OCI_NW_SUPPORTED + ,NW_UNSUPPORTED = OCI_NW_UNSUPPORTED + ,AC_DDL = OCI_AC_DDL + ,NO_AC_DDL = OCI_NO_AC_DDL + ,LOCK_IMMEDIATE = OCI_LOCK_IMMEDIATE + ,LOCK_DELAYED = OCI_LOCK_DELAYED + }; + + MetaData(const MetaData &omd); + unsigned int getAttributeCount() const + ; + AttrId getAttributeId(unsigned int attributenum) const + ; + Type getAttributeType(unsigned int attributenum) const + ; + int getInt(MetaData::AttrId attrid) const + ; + bool getBoolean(MetaData::AttrId attrid) const + ; + unsigned int getUInt(MetaData::AttrId attrid) const + ; + OCCI_STD_NAMESPACE::string getString(MetaData::AttrId attrid) const + ; + UString getUString(MetaData::AttrId attrid) const + ; + Number getNumber(MetaData::AttrId attrid) const + ; + RefAny getRef(MetaData::AttrId attrid) const + ; + Timestamp getTimestamp(MetaData::AttrId attrid) const + ; + MetaData getMetaData(MetaData::AttrId attrid) const + ; + OCCI_STD_NAMESPACE::vector getVector(MetaData::AttrId attrid) + const ; + void operator =(const MetaData &omd); + + ~MetaData(); + + private: + + enum ociAttrType { OCI_UB1, + OCI_UB2, + OCI_UB4, + OCI_SB1, + OCI_WORD, + OCI_UB1_BOOL, + OCI_UB1PTR_TIMESTAMP, + OCI_UB1PTR_NUMBER, + OCI_TEXTPTR, + OCI_DVOIDPTR_PARAM, + OCI_DVOIDPTR_PARAMLIST, + OCI_OCIREFPTR, + OCI_OCIDURATION, + OCI_OCITYPECODE, + OCI_OCITYPEENCAP, + OCI_OCITYPEPARAMMODE, + OCI_OCIPRECISION + }; + + enum AttrCount {COMMON_ATTR_COUNT = 5, + TABLE_ATTR_COUNT = 15, + VIEW_ATTR_COUNT = 7, + FUNCPROC_ATTR_COUNT = 4, + PKG_ATTR_COUNT = 2, + TYP_ATTR_COUNT = 27, + TYPEATTR_ATTR_COUNT = 14, + TYPEMTHD_ATTR_COUNT = 16, + COLL_ATTR_COUNT = 12, + SYN_ATTR_COUNT = 4, + SEQ_ATTR_COUNT = 7, + COL_ATTR_COUNT = 15, + ARG_TYPARG_TYPRES_ATTR_COUNT = 20, + SCHEMA_ATTR_COUNT = 1, + DATABASE_ATTR_COUNT = 13, + UNK_ATTR_COUNT = 0 + }; + + static const AttrId commonAttrId[COMMON_ATTR_COUNT]; + static const ociAttrType commonAttrType[COMMON_ATTR_COUNT]; + static const AttrId tableAttrId[TABLE_ATTR_COUNT]; + static const ociAttrType tableAttrType[TABLE_ATTR_COUNT]; + static const AttrId viewAttrId[VIEW_ATTR_COUNT]; + static const ociAttrType viewAttrType[VIEW_ATTR_COUNT]; + static const AttrId funcprocAttrId[FUNCPROC_ATTR_COUNT]; + static const ociAttrType funcprocAttrType[FUNCPROC_ATTR_COUNT]; + static const AttrId pkgAttrId[PKG_ATTR_COUNT]; + static const ociAttrType pkgAttrType[PKG_ATTR_COUNT]; + static const AttrId typAttrId[TYP_ATTR_COUNT]; + static const ociAttrType typAttrType[TYP_ATTR_COUNT]; + static const AttrId typeattrAttrId[TYPEATTR_ATTR_COUNT]; + static const ociAttrType typeattrAttrType[TYPEATTR_ATTR_COUNT]; + static const AttrId typmethdAttrId[TYPEMTHD_ATTR_COUNT]; + static const ociAttrType typemthdAttrType[TYPEMTHD_ATTR_COUNT]; + static const AttrId collAttrId[COLL_ATTR_COUNT]; + static const ociAttrType collAttrType[COLL_ATTR_COUNT]; + static const AttrId synAttrId[SYN_ATTR_COUNT]; + static const ociAttrType synAttrType[SYN_ATTR_COUNT]; + static const AttrId seqAttrId[SEQ_ATTR_COUNT]; + static const ociAttrType seqAttrType[SEQ_ATTR_COUNT]; + static const AttrId colAttrId[COL_ATTR_COUNT]; + static const ociAttrType colAttrType[COL_ATTR_COUNT]; + static const AttrId argtargtresAttrId[ARG_TYPARG_TYPRES_ATTR_COUNT]; + static const ociAttrType argtargtresAttrType[ + ARG_TYPARG_TYPRES_ATTR_COUNT]; + static const AttrId schemaAttrId[SCHEMA_ATTR_COUNT]; + static const ociAttrType schemaAttrType[SCHEMA_ATTR_COUNT]; + static const AttrId databaseAttrId[DATABASE_ATTR_COUNT]; + static const ociAttrType databaseAttrType[DATABASE_ATTR_COUNT]; + + Ptr metaDataImplPtr; + const OCIParam* paramhp; + const ConnectionImpl* sesn; + const AttrId* attrIdArray; + const ociAttrType* attrTypeArray; + AttrCount attrCount; + + MetaData(const Connection *sessp, const OCCI_STD_NAMESPACE::string& objName, + ParamType prmtyp ) ; + MetaData(const Connection *sessp, const UString& objName, + ParamType prmtyp ) ; + MetaData(const Connection *sessp, + const RefAny& ref) ; + MetaData(const Connection *sessp, MetaDataImpl *implPtr, + OCIParam* parm) ; + MetaData(const Connection *sessp, MetaDataImpl *implPtr, + OCIParam *parm, ub1 parmTyp) ; + ub1 getParamType(OCIParam* prm) const ; + const AttrId* getAttrIdArrayAddr(ub1 prmTyp) const; + const ociAttrType* getAttrTypeArrayAddr(ub1 prmTyp) const; + AttrCount getAttrCount(ub1 prmTyp) const; + Type getType(ociAttrType typ) const; + bool isListTypeAttribute(AttrId attrid,ub1 ptyp) const; + boolean isInvalidAttrId(AttrId attrid,sb4* pos, + boolean* isTypeSpecificAttrPtr) const; + ociAttrType getValidAttrType(sb4 index, boolean isTypeSpecificAttr) + const; + + int getListType (const OCIParam *plist) const; + unsigned int getLowerBound(int ltype) const; + unsigned int getUpperBound(unsigned int ltype, + unsigned int paramnum) const; + friend class ConnectionImpl; + friend class ResultSetImpl; + +}; + +//return codes for user callbacks +enum +{ + OCCI_SUCCESS = OCI_SUCCESS, + FO_RETRY = OCI_FO_RETRY +}; + + +class Connection +{ + public : + + // specifies the type of proxy to be created, + // used for future enhancements + enum ProxyType + {PROXY_DEFAULT + }; + + enum FailOverType + { + FO_NONE = OCI_FO_NONE, + FO_SESSION = OCI_FO_SESSION, + FO_SELECT = OCI_FO_SELECT + }; + + enum FailOverEventType + { + FO_BEGIN = OCI_FO_BEGIN, + FO_END = OCI_FO_END, + FO_ABORT = OCI_FO_ABORT, + FO_REAUTH = OCI_FO_REAUTH, + FO_ERROR = OCI_FO_ERROR + }; + + enum Purity + { + DEFAULT = OCI_ATTR_PURITY_DEFAULT, + NEW = OCI_ATTR_PURITY_NEW, + SELF = OCI_ATTR_PURITY_SELF + }; + + virtual ~Connection() { } + virtual Statement* createStatement( + const OCCI_STD_NAMESPACE::string &sql = "") + =0; + virtual void terminateStatement(Statement *statement) =0; + virtual void commit() =0; + virtual void rollback() =0; + virtual MetaData getMetaData(const OCCI_STD_NAMESPACE::string &object, + MetaData::ParamType prmtyp + = MetaData::PTYPE_UNK) const + =0; + virtual MetaData getMetaData(const RefAny &ref) const + =0; + virtual OCCI_STD_NAMESPACE::string getClientCharSet() const + =0; + virtual OCCI_STD_NAMESPACE::string getClientNCHARCharSet() const + =0; + virtual void changePassword(const OCCI_STD_NAMESPACE::string &user, + const OCCI_STD_NAMESPACE::string &oldPassword, + const OCCI_STD_NAMESPACE::string &newPassword) + =0; + virtual void flushCache() =0; + + virtual OCIServer* getOCIServer() const =0; + virtual OCISvcCtx* getOCIServiceContext() const =0; + virtual OCISession* getOCISession() const =0; + + //new interfaces + + virtual Statement* createStatement(const UString &sql) = 0; + virtual MetaData getMetaData(const UString &object, + MetaData::ParamType prmtyp + = MetaData::PTYPE_UNK) const + =0; + virtual UString getClientCharSetUString() const + =0; + virtual UString getClientNCHARCharSetUString() const + =0; + virtual void changePassword(const UString &user, + const UString &oldPassword, + const UString &newPassword) + =0; + virtual OCCI_STD_NAMESPACE::string getTag() const =0; + virtual void setStmtCacheSize(unsigned int cacheSize) = 0; + virtual unsigned int getStmtCacheSize() const =0; + virtual Statement* createStatement(const OCCI_STD_NAMESPACE::string &sql, + const OCCI_STD_NAMESPACE::string &tag) = 0; + virtual void terminateStatement(Statement* stmt, + const OCCI_STD_NAMESPACE::string &tag) = 0; + virtual bool isCached(const OCCI_STD_NAMESPACE::string &sql, + const OCCI_STD_NAMESPACE::string &tag = "") = 0; + virtual void registerSubscriptions( + const OCCI_STD_NAMESPACE::vector& sub) =0; + virtual void unregisterSubscription(const aq::Subscription& sub) =0; + virtual void postToSubscriptions( + const OCCI_STD_NAMESPACE::vector& sub) =0; + virtual Statement* createStatement(const UString &sql, + const UString &tag) = 0; + virtual void terminateStatement(Statement* stmt, + const UString &tag) = 0; + virtual bool isCached(const UString &sql, + const UString &tag) = 0; + virtual void setTAFNotify( + int (*notifyFn)(Environment *env, Connection *conn, void *ctx, + FailOverType foType, FailOverEventType foEvent), + void *ctx) = 0; + virtual OCCI_STD_NAMESPACE::string getServerVersion() const =0; + virtual UString getServerVersionUString() const =0; + virtual void cancel() =0; +}; + +class StatelessConnectionPool +{ + public : + + enum PoolType + { + HETEROGENEOUS = OCI_DEFAULT, + HOMOGENEOUS = OCI_SPC_HOMOGENEOUS, + NO_RLB = OCI_SPC_NO_RLB, + USES_EXT_AUTH = 16 + }; + + enum BusyOption + { + WAIT = OCI_SPOOL_ATTRVAL_WAIT, + NOWAIT = OCI_SPOOL_ATTRVAL_NOWAIT, + FORCEGET = OCI_SPOOL_ATTRVAL_FORCEGET + }; + + enum DestroyMode + { + DEFAULT = OCI_DEFAULT, + SPD_FORCE = OCI_SPD_FORCE + }; + + virtual ~StatelessConnectionPool() {} + virtual unsigned int getBusyConnections() const =0; + virtual unsigned int getOpenConnections() const =0; + virtual unsigned int getMinConnections() const =0; + virtual unsigned int getMaxConnections() const =0; + virtual unsigned int getIncrConnections() const =0; + virtual OCCI_STD_NAMESPACE::string getPoolName() const =0; + virtual unsigned int getTimeOut() const =0; + virtual void setBusyOption(BusyOption busyOption) =0; + virtual BusyOption getBusyOption() const =0; + virtual void setTimeOut(unsigned int connTimeOut =0) =0; + virtual void setPoolSize(unsigned int maxConn =1, + unsigned int minConn =0, unsigned int incrConn =1) =0; + virtual Connection* getConnection( + const OCCI_STD_NAMESPACE::string &tag ="") =0; + virtual Connection* getConnection( + const OCCI_STD_NAMESPACE::string &userName, + const OCCI_STD_NAMESPACE::string &password, + const OCCI_STD_NAMESPACE::string &tag = "") =0; + virtual Connection* getAnyTaggedConnection( + const OCCI_STD_NAMESPACE::string &tag = "") =0; + virtual Connection* getAnyTaggedConnection( + const OCCI_STD_NAMESPACE::string &userName, + const OCCI_STD_NAMESPACE::string &Password, + const OCCI_STD_NAMESPACE::string &tag = "") =0; + virtual Connection* getProxyConnection( + const OCCI_STD_NAMESPACE::string &name, + OCCI_STD_NAMESPACE::string roles[], unsigned int numRoles, + const OCCI_STD_NAMESPACE::string &tag = "", + Connection::ProxyType proxyType = Connection::PROXY_DEFAULT) =0; + virtual Connection* getProxyConnection( + const OCCI_STD_NAMESPACE::string &name, + const OCCI_STD_NAMESPACE::string &tag = "" , + Connection::ProxyType proxyType = Connection::PROXY_DEFAULT) =0; + virtual Connection* getAnyTaggedProxyConnection( + const OCCI_STD_NAMESPACE::string &name, + OCCI_STD_NAMESPACE::string roles[], unsigned int numRoles, + const OCCI_STD_NAMESPACE::string &tag = "", + Connection::ProxyType proxyType = Connection::PROXY_DEFAULT) =0; + virtual Connection* getAnyTaggedProxyConnection( + const OCCI_STD_NAMESPACE::string &name, + const OCCI_STD_NAMESPACE::string &tag="", + Connection::ProxyType proxyType = Connection::PROXY_DEFAULT ) =0; + virtual void releaseConnection (Connection *connection, + const OCCI_STD_NAMESPACE::string &tag = "") =0; + virtual void terminateConnection (Connection *connection) =0; + virtual void setStmtCacheSize(unsigned int cacheSize) =0; + virtual unsigned int getStmtCacheSize() const =0; + + virtual Connection* getConnection(const UString &tag)=0; + virtual Connection* getConnection(const UString &userName, + const UString &password, + const UString &tag)=0; + virtual Connection* getAnyTaggedConnection(const UString &tag)=0; + virtual Connection* getAnyTaggedConnection( const UString &userName, + const UString &Password, const UString &tag)=0 ; + virtual Connection* getProxyConnection(const UString &name, + OCCI_STD_NAMESPACE::string roles[], unsigned int numRoles, + const UString &tag, + Connection::ProxyType proxyType = Connection::PROXY_DEFAULT)=0; + virtual Connection* getProxyConnection(const UString &name, + const UString &tag, Connection::ProxyType + proxyType = Connection::PROXY_DEFAULT)=0; + virtual Connection* getAnyTaggedProxyConnection(const UString &name, + OCCI_STD_NAMESPACE::string roles[], unsigned int numRoles, + const UString &tag, + Connection::ProxyType proxyType = Connection::PROXY_DEFAULT)=0; + virtual Connection* getAnyTaggedProxyConnection(const UString &name, + const UString &tag, + Connection::ProxyType proxyType = Connection::PROXY_DEFAULT )=0; + virtual void releaseConnection(Connection *connection, + const UString &tag)=0; + + + virtual Connection* getConnection( + const OCCI_STD_NAMESPACE::string &connectionClass, + const Connection::Purity purity, + const OCCI_STD_NAMESPACE::string &tag = "") =0; + + virtual Connection* getConnection( + const OCCI_STD_NAMESPACE::string &userName, + const OCCI_STD_NAMESPACE::string &password, + const OCCI_STD_NAMESPACE::string &connectionClass, + const Connection::Purity purity, + const OCCI_STD_NAMESPACE::string &tag = "") =0; + + virtual Connection* getAnyTaggedConnection( + const OCCI_STD_NAMESPACE::string &connectionClass, + const Connection::Purity purity, + const OCCI_STD_NAMESPACE::string &tag = "") =0; + + virtual Connection* getAnyTaggedConnection( + const OCCI_STD_NAMESPACE::string &userName, + const OCCI_STD_NAMESPACE::string &Password, + const OCCI_STD_NAMESPACE::string &connectionClass, + const Connection::Purity purity, + const OCCI_STD_NAMESPACE::string &tag = "")= 0; + + virtual Connection* getProxyConnection( + const OCCI_STD_NAMESPACE::string &name, + OCCI_STD_NAMESPACE::string roles[], unsigned int numRoles, + const OCCI_STD_NAMESPACE::string &connectionClass, + const Connection::Purity purity, + const OCCI_STD_NAMESPACE::string &tag = "", + Connection::ProxyType proxyType = Connection::PROXY_DEFAULT) = 0; + + virtual Connection* getProxyConnection( + const OCCI_STD_NAMESPACE::string &name, + const OCCI_STD_NAMESPACE::string &connectionClass, + const Connection::Purity purity, + const OCCI_STD_NAMESPACE::string &tag = "", + Connection::ProxyType proxyType = Connection::PROXY_DEFAULT) = 0; + + virtual Connection* getAnyTaggedProxyConnection( + const OCCI_STD_NAMESPACE::string &name, + OCCI_STD_NAMESPACE::string roles[], unsigned int numRoles, + const OCCI_STD_NAMESPACE::string &connectionClass, + const Connection::Purity purity, + const OCCI_STD_NAMESPACE::string &tag = "", + Connection::ProxyType proxyType = Connection::PROXY_DEFAULT) = 0; + + + virtual Connection* getAnyTaggedProxyConnection( + const OCCI_STD_NAMESPACE::string &name, + const OCCI_STD_NAMESPACE::string &connectionClass, + const Connection::Purity purity, + const OCCI_STD_NAMESPACE::string &tag = "", + Connection::ProxyType proxyType = Connection::PROXY_DEFAULT) = 0; + + + virtual Connection* getConnection( + const UString &connectionClass, + const Connection::Purity purity, + const UString &tag) = 0; + + + + virtual Connection* getConnection(const UString &userName, + const UString &password, + const UString &connectionClass, + const Connection::Purity purity, + const UString &tag) = 0; + + virtual Connection* getAnyTaggedConnection( + const UString &connectionClass, + const Connection::Purity purity, + const UString &tag) =0; + + + + virtual Connection* getAnyTaggedConnection( const UString &userName, + const UString &Password, + const UString &connectionClass, + const Connection::Purity purity, + const UString &tag) =0; + + virtual Connection* getProxyConnection(const UString &name, + OCCI_STD_NAMESPACE::string roles[], unsigned int numRoles, + const UString &connectionClass, + const Connection::Purity purity, + const UString &tag, Connection::ProxyType proxyType) =0; + + virtual Connection* getProxyConnection(const UString &name, + const UString &connectionClass, + const Connection::Purity purity, + const UString &tag, Connection::ProxyType proxyType) = 0; + + + virtual Connection* getAnyTaggedProxyConnection(const UString &name, + OCCI_STD_NAMESPACE::string roles[], unsigned int numRoles, + const UString &connectionClass, + const Connection::Purity purity, + const UString &tag, + Connection::ProxyType proxyType) = 0; + + virtual Connection* getAnyTaggedProxyConnection(const UString &name, + const UString &connectionClass, + const Connection::Purity purity, + const UString &tag, + Connection::ProxyType proxyType ) =0; + +}; + + +class ConnectionPool +{ + public : + + virtual ~ConnectionPool() {} + virtual unsigned int getBusyConnections() const + =0; + virtual unsigned int getOpenConnections() const + =0; + virtual unsigned int getMinConnections() const + =0; + virtual unsigned int getMaxConnections() const + =0; + virtual unsigned int getIncrConnections() const + =0; + virtual OCCI_STD_NAMESPACE::string getPoolName() const + =0; + virtual unsigned int getTimeOut() const + =0; + virtual void setErrorOnBusy() + =0; + virtual void setTimeOut(unsigned int connTimeOut =0) + =0; + virtual void setPoolSize(unsigned int minConn =0, + unsigned int maxConn =1, unsigned int incrConn =1) + =0; + virtual Connection* createConnection( + const OCCI_STD_NAMESPACE::string &userName, + const OCCI_STD_NAMESPACE::string &password) =0; + + virtual Connection* createProxyConnection( + const OCCI_STD_NAMESPACE::string &name, + OCCI_STD_NAMESPACE::string roles[], unsigned int numRoles, + Connection::ProxyType proxyType = + Connection::PROXY_DEFAULT) =0; + + virtual Connection* createProxyConnection( + const OCCI_STD_NAMESPACE::string &name, + Connection::ProxyType proxyType = + Connection::PROXY_DEFAULT) =0; + + virtual void terminateConnection + (Connection *connection) =0; + + //new interfaces + + virtual Connection* createConnection( + const UString &userName, + const UString &password) =0; + + virtual Connection* createProxyConnection(const UString &name, + OCCI_STD_NAMESPACE::string roles[], unsigned int numRoles, + Connection::ProxyType proxyType = + Connection::PROXY_DEFAULT) =0; + + virtual Connection* createProxyConnection(const UString &name, + Connection::ProxyType proxyType = + Connection::PROXY_DEFAULT) =0; + + virtual void setStmtCacheSize(unsigned int cacheSize) =0; + virtual unsigned int getStmtCacheSize() const =0; + + virtual UString getPoolNameUString() const + =0; +}; + +class Environment +{ + public: + // class constants + + enum Mode + { + DEFAULT = OCI_DEFAULT, + OBJECT = OCI_OBJECT, + SHARED = OCI_SHARED, + NO_USERCALLBACKS = OCI_NO_UCB, + THREADED_MUTEXED = OCI_THREADED, + THREADED_UNMUTEXED = OCI_THREADED | OCI_NO_MUTEX, + EVENTS = OCI_EVENTS, + USE_LDAP = OCI_USE_LDAP + }; + + virtual ~Environment(){} + + // public methods + + static Environment * createEnvironment( + Mode mode = DEFAULT, + void *ctxp = 0, + void *(*malocfp)(void *ctxp, size_t size) = 0, + void *(*ralocfp)(void *ctxp, void *memptr, + size_t newsize) = 0, + void (*mfreefp)(void *ctxp, void *memptr) = 0); + + static Environment * createEnvironment( + const OCCI_STD_NAMESPACE::string &charset, + const OCCI_STD_NAMESPACE::string &ncharset, + Mode mode = DEFAULT, + void *ctxp = 0, + void *(*malocfp)(void *ctxp, size_t size) = 0, + void *(*ralocfp)(void *ctxp, void *memptr, + size_t newsize) = 0, + void (*mfreefp)(void *ctxp, void *memptr) = 0); + + static void terminateEnvironment(Environment *env); + + static Environment* getXAEnvironment(const + OCCI_STD_NAMESPACE::string& dbname); + + static void releaseXAEnvironment(Environment *env); + + static void getClientVersion( int &majorVersion, int &minorVersion, + int &updateNum, int &patchNum, + int &portUpdateNum ); + + + virtual Connection * createConnection( + const OCCI_STD_NAMESPACE::string &userName, + const OCCI_STD_NAMESPACE::string &password, + const OCCI_STD_NAMESPACE::string &connectString = "") = 0; + + virtual void terminateConnection(Connection *connection) = 0; + + virtual ConnectionPool* createConnectionPool( + const OCCI_STD_NAMESPACE::string &poolUserName, + const OCCI_STD_NAMESPACE::string &poolPassword, + const OCCI_STD_NAMESPACE::string &connectString ="", + unsigned int minConn =0, + unsigned int maxConn =1, unsigned int incrConn =1) = 0; + + virtual void terminateConnectionPool(ConnectionPool *poolp) = 0; + + virtual unsigned int getCurrentHeapSize() const = 0; + + virtual OCIEnv * getOCIEnvironment() const = 0; + + virtual Map *getMap() const = 0; + + virtual void setCacheMaxSize(unsigned int maxSize) = 0; + + virtual unsigned int getCacheMaxSize() const = 0; + + virtual void setCacheOptSize(unsigned int OptSize) = 0; + + virtual unsigned int getCacheOptSize() const = 0; + + + //new interfaces + + virtual Connection * createConnection(const UString &userName, + const UString &password, const UString &connectString) = 0; + + virtual ConnectionPool* createConnectionPool( + const UString &poolUserName, + const UString &poolPassword, const UString &connectString, + unsigned int minConn =0, + unsigned int maxConn =1, unsigned int incrConn =1) = 0; + + virtual Connection* getXAConnection(const + OCCI_STD_NAMESPACE::string& dbname) = 0; + + virtual void releaseXAConnection(Connection* conn) =0; + + virtual StatelessConnectionPool* createStatelessConnectionPool( + const OCCI_STD_NAMESPACE::string &poolUserName, + const OCCI_STD_NAMESPACE::string &poolPassword, + const OCCI_STD_NAMESPACE::string &connectString = "", + unsigned int maxConn = 1, unsigned int minConn = 0, + unsigned int incrConn = 1, + StatelessConnectionPool::PoolType pType + = StatelessConnectionPool::HETEROGENEOUS) = 0; + + virtual StatelessConnectionPool* createStatelessConnectionPool( + const UString &poolUserName, + const UString &poolPassword, + const UString &connectString, + unsigned int maxConn = 1, unsigned int minConn = 0, + unsigned int incrConn = 1, + StatelessConnectionPool::PoolType pType + = StatelessConnectionPool::HETEROGENEOUS) = 0; + + virtual void terminateStatelessConnectionPool(StatelessConnectionPool *poolp, + StatelessConnectionPool::DestroyMode mode = StatelessConnectionPool::DEFAULT) + = 0; + virtual void setLDAPAuthentication(unsigned int mode) =0; + + virtual unsigned int getLDAPAuthentication() const =0; + + virtual void setLDAPLoginNameAndPassword( + const OCCI_STD_NAMESPACE::string &login, + const OCCI_STD_NAMESPACE::string &passwd) =0; + + virtual void setLDAPAdminContext(const OCCI_STD_NAMESPACE::string &ctx)=0; + + virtual OCCI_STD_NAMESPACE::string getLDAPAdminContext() const =0; + + virtual void setLDAPHostAndPort(const OCCI_STD_NAMESPACE::string &host, + unsigned int port) =0; + + virtual OCCI_STD_NAMESPACE::string getLDAPHost() const =0; + + virtual unsigned int getLDAPPort() const =0; + + virtual void registerSubscriptions( + const OCCI_STD_NAMESPACE::vector& sub) =0; + + virtual void unregisterSubscription(const aq::Subscription& sub) =0; + + virtual void enableSubscription(const aq::Subscription& sub) =0; + + virtual void disableSubscription(const aq::Subscription& sub) =0; + + virtual bool getCacheSortedFlush() const = 0; + + virtual void setCacheSortedFlush(bool flag) = 0; + + virtual Connection * createConnection( + const OCCI_STD_NAMESPACE::string &userName, + const OCCI_STD_NAMESPACE::string &password, + const OCCI_STD_NAMESPACE::string &connectString, + const OCCI_STD_NAMESPACE::string &connectionClass, + const Connection::Purity purity) = 0; + + virtual Connection * createConnection(const UString &userName, + const UString &password, const UString &connectString, + const UString &connectionclass, + const Connection::Purity purity) =0; + + private: + +}; + + + +class Map +{ + public: + + virtual ~Map(){} + virtual void put(const OCCI_STD_NAMESPACE::string&, void *(*)(void *), + void (*)(void *, void *)) = 0; + virtual void getReadSQL( + void *, unsigned int, void *, unsigned int, void **) const = 0; + virtual void getWriteSQL( + void *, unsigned int, void *, unsigned int, void **) const = 0; + virtual void put(const OCCI_STD_NAMESPACE::string&, + const OCCI_STD_NAMESPACE::string&, void *(*)(void *), + void (*)(void *, void *)) = 0; + virtual void putUTF16(const OCCI_STD_NAMESPACE::string&, + const OCCI_STD_NAMESPACE::string&, void *(*)(void *), + void (*)(void *, void *)) = 0; + + private: +}; + + + +class SQLException : public OCCI_STD_NAMESPACE::exception +{ + public: + + virtual int getErrorCode() const; + + virtual OCCI_STD_NAMESPACE::string getMessage() const; + + const char *what() const throw(); + + virtual void setErrorCtx(void *ctx); + + SQLException(); + + SQLException(const SQLException &e); + + void operator=(const SQLException &other); + + virtual ~SQLException() throw(); + + virtual int getXAErrorCode(const OCCI_STD_NAMESPACE::string& dbname) const; + + virtual UString getUStringMessage() const; + + virtual OCCI_STD_NAMESPACE::string getNLSMessage(Environment *env) const; + + virtual UString getNLSUStringMessage(Environment *env) const; + + protected: + + Ptr ptr_; + SQLException(SQLExceptionImpl *ptr); + + friend SQLException SQLExceptionCreate(int errorCode); + friend SQLException SQLExceptionCreate(void *handle, + int handleType); + friend class BatchSQLException; +}; + +class BatchSQLException : public SQLException +{ + public: + virtual ~BatchSQLException() throw(); + + unsigned int getFailedRowCount() const; + unsigned int getRowNum( unsigned int index ) const; + SQLException getException ( unsigned int index ) const; + + private: + BatchSQLException(); + + BatchSQLException(SQLExceptionImpl *ptr); + friend BatchSQLException BatchSQLExceptionCreate(void *handle); +}; + +class Statement +{ + public: + // class constants + + virtual ~Statement() {} + + enum Status + { + UNPREPARED, + PREPARED, + RESULT_SET_AVAILABLE, + UPDATE_COUNT_AVAILABLE, + NEEDS_STREAM_DATA, + STREAM_DATA_AVAILABLE + }; + + // common methods + + virtual void setSQL(const OCCI_STD_NAMESPACE::string &sql) = 0; + + virtual OCCI_STD_NAMESPACE::string getSQL() const = 0; + + virtual Status execute(const OCCI_STD_NAMESPACE::string &sql = "") = 0; + + virtual ResultSet * getResultSet() = 0; + + virtual unsigned int getUpdateCount() const = 0; + + virtual ResultSet * executeQuery( + const OCCI_STD_NAMESPACE::string &sql = "") = 0; + + virtual unsigned int executeUpdate( + const OCCI_STD_NAMESPACE::string &sql = "") = 0; + + virtual Status status() const = 0; + + virtual void closeResultSet(ResultSet *resultSet) = 0; + + virtual void setPrefetchRowCount(unsigned int rowCount) = 0; + + virtual void setPrefetchMemorySize(unsigned int bytes) = 0; + + virtual void setAutoCommit(bool autoCommit) = 0; + + virtual bool getAutoCommit() const = 0; + + virtual OCIStmt * getOCIStatement() const = 0; + + + // methods for prepared statements with IN + // parameters + + virtual void setMaxParamSize(unsigned int paramIndex,unsigned int maxSize)=0; + + virtual unsigned int getMaxParamSize(unsigned int paramIndex) const = 0; + + virtual void setNull(unsigned int paramIndex, Type type) = 0; + + virtual void setInt(unsigned int paramIndex, int x) = 0; + + virtual void setUInt(unsigned int paramIndex, unsigned int x) = 0; + + virtual void setFloat(unsigned int paramIndex, float x) = 0; + + virtual void setDouble(unsigned int paramIndex, double x) = 0; + + virtual void setNumber(unsigned int paramIndex, const Number &x) = 0; + + virtual void setString(unsigned int paramIndex, + const OCCI_STD_NAMESPACE::string &x) = 0; + + virtual void setBytes(unsigned int paramIndex, const Bytes &x) = 0; + + virtual void setDate(unsigned int paramIndex, const Date &x) = 0; + + virtual void setTimestamp(unsigned int paramIndex, const Timestamp &x) = 0; + + virtual void setBlob(unsigned int paramIndex, const Blob &x) = 0; + + virtual void setClob(unsigned int paramIndex, const Clob &x) = 0; + + virtual void setBfile(unsigned int paramIndex, const Bfile &x) = 0; + + virtual void setIntervalYM(unsigned int paramIndex, const IntervalYM &x) = 0; + + virtual void setIntervalDS(unsigned int paramIndex, const IntervalDS &x) = 0; + + virtual void setRowid(unsigned int paramIndex, const Bytes &x) = 0; + + virtual void setRef(unsigned int paramIndex, const RefAny &x) = 0; + + virtual void setObject(unsigned int paramIndex, PObject * x) = 0; + + virtual void setDataBuffer(unsigned int paramIndex, void *buffer, + Type type, + sb4 size, ub2 *length, sb2 *ind = NULL, + ub2 *rc = NULL) = 0; + + virtual void setDataBufferArray(unsigned int paramIndex, void *buffer, + Type type, + ub4 arraySize, ub4 *arrayLength, + sb4 elementSize, + ub2 *elementLength, sb2 *ind = NULL, + ub2 *rc = NULL) = 0; + + virtual void setCharSet(unsigned int paramIndex, + const OCCI_STD_NAMESPACE::string & charSet) = 0; + + virtual OCCI_STD_NAMESPACE::string getCharSet(unsigned int paramIndex) + const = 0; + + virtual void setDatabaseNCHARParam( + unsigned int paramIndex, bool isNCHAR) = 0; + + virtual bool getDatabaseNCHARParam(unsigned int paramIndex) const = 0; + + virtual void closeStream(Stream *stream) =0; + + virtual Stream * getStream(unsigned int paramIndex) = 0; + + virtual unsigned int getCurrentStreamParam() const = 0; + + virtual unsigned int getCurrentStreamIteration() const = 0; + + virtual void setBinaryStreamMode(unsigned int colIndex, + unsigned int size) =0; + + virtual void setCharacterStreamMode(unsigned int colIndex, + unsigned int size) =0; + + virtual void setMaxIterations(unsigned int maxIterations) = 0; + + virtual unsigned int getMaxIterations() const = 0; + + virtual void addIteration() = 0; + + virtual unsigned int getCurrentIteration() const = 0; + + virtual Status executeArrayUpdate(unsigned int arrayLength) = 0; + + + // methods for Callable Statements + + virtual void registerOutParam(unsigned int paramIndex, Type type, + unsigned int maxSize=0, const OCCI_STD_NAMESPACE::string &sqltype="") = 0; + + virtual bool isNull(unsigned int paramIndex) const = 0; + + virtual bool isTruncated(unsigned int paramIndex) const + =0; + + + virtual void setErrorOnNull(unsigned int paramIndex, + bool causeException) = 0; + + virtual void setErrorOnTruncate(unsigned int paramIndex, + bool causeException) = 0; + + virtual int preTruncationLength(unsigned int paramIndex) const + =0; + + + virtual int getInt(unsigned int paramIndex) = 0; + + virtual unsigned int getUInt(unsigned int paramIndex) = 0; + + virtual float getFloat(unsigned int paramIndex) = 0; + + virtual double getDouble(unsigned int paramIndex) = 0; + + virtual Number getNumber(unsigned int paramIndex) = 0; + + virtual OCCI_STD_NAMESPACE::string getString(unsigned int paramIndex) = 0; + + virtual Bytes getBytes(unsigned int paramIndex) = 0; + + virtual Date getDate(unsigned int paramIndex) = 0; + + virtual Timestamp getTimestamp(unsigned int paramIndex) = 0; + + virtual Bytes getRowid(unsigned int paramIndex) = 0; + + virtual PObject * getObject(unsigned int paramIndex) = 0; + + virtual Blob getBlob(unsigned int paramIndex) = 0; + + virtual Clob getClob(unsigned int paramIndex) = 0; + + virtual Bfile getBfile(unsigned int paramIndex) = 0; + + virtual IntervalYM getIntervalYM(unsigned int paramIndex) = 0; + + virtual IntervalDS getIntervalDS(unsigned int paramIndex) = 0; + + virtual RefAny getRef(unsigned int paramIndex) = 0; + + virtual ResultSet * getCursor(unsigned int paramIndex) = 0; + + virtual Connection* getConnection() const =0; + + //new interfaces + + virtual void setRef(unsigned int paramIndex, const RefAny &x, + const OCCI_STD_NAMESPACE::string &typName, + const OCCI_STD_NAMESPACE::string &schName = "") = 0; + + virtual void setSQLUString(const UString &sql) = 0; + + virtual UString getSQLUString() const = 0; + + virtual Status execute(const UString &sql) = 0; + + virtual ResultSet * executeQuery( + const UString &sql) = 0; + + virtual unsigned int executeUpdate( + const UString &sql) = 0; + + virtual void setBFloat(unsigned int paramIndex, const BFloat &fval) = 0; + + virtual void setBDouble(unsigned int paramIndex, const BDouble &dval) = 0; + + virtual void setUString(unsigned int paramIndex, + const UString &x) = 0; + + virtual void setCharSetUString(unsigned int paramIndex, + const UString & charSet) = 0; + + virtual UString getCharSetUString(unsigned int paramIndex) + const = 0; + + virtual void registerOutParam(unsigned int paramIndex, Type type, + unsigned int maxSize, const OCCI_STD_NAMESPACE::string &typName, + const OCCI_STD_NAMESPACE::string &schName) = 0; + + virtual void registerOutParam(unsigned int paramIndex, Type type, + unsigned int maxSize, const UString &typName, + const UString &schName) = 0; + + virtual BFloat getBFloat(unsigned int paramIndex) = 0; + + virtual BDouble getBDouble(unsigned int paramIndex) = 0; + + virtual UString getUString(unsigned int paramIndex) = 0; + + virtual void disableCaching() =0; + + virtual void setRef(unsigned int paramIndex, const RefAny &x, + const UString &typName, + const UString &schName) = 0; + + virtual void setBinaryStreamMode(unsigned int colIndex, + unsigned int size, bool INArg) =0; + + virtual void setCharacterStreamMode(unsigned int colIndex, + unsigned int size, bool INArg) =0; + + virtual void setNull(unsigned int paramIndex, Type type, + const OCCI_STD_NAMESPACE::string &typeName, + const OCCI_STD_NAMESPACE::string &schemaName = "") = 0; + + virtual void setNull(unsigned int paramIndex, Type type, + UString &typeName, UString &schemaName) = 0; + + virtual void setBatchErrorMode( bool batchErrorMode ) =0; + + virtual bool getBatchErrorMode( ) const =0; + +}; + + + +class ResultSet +{ + public: + // class constants + + enum Status + { + END_OF_FETCH = 0, + DATA_AVAILABLE, + STREAM_DATA_AVAILABLE + }; + virtual ~ResultSet(){} + + // public methods + + virtual Status next(unsigned int numRows = 1) = 0; + + virtual Status status() const = 0; + + virtual unsigned int getNumArrayRows() const = 0; + + virtual void cancel() = 0; + + virtual void setMaxColumnSize(unsigned int colIndex, unsigned int max) = 0; + + virtual unsigned int getMaxColumnSize(unsigned int colIndex) const = 0; + + virtual bool isNull(unsigned int colIndex) const = 0; + + virtual bool isTruncated(unsigned int paramIndex) const + =0; + + virtual void setErrorOnNull(unsigned int colIndex, bool causeException) = 0; + virtual void setErrorOnTruncate(unsigned int paramIndex, + bool causeException) =0; + + virtual int preTruncationLength(unsigned int paramIndex) const + =0; + + virtual int getInt(unsigned int colIndex) = 0; + + virtual unsigned int getUInt(unsigned int colIndex) = 0; + + virtual float getFloat(unsigned int colIndex) = 0; + + virtual double getDouble(unsigned int colIndex) = 0; + + virtual Number getNumber(unsigned int colIndex) = 0; + + virtual OCCI_STD_NAMESPACE::string getString(unsigned int colIndex) = 0; + + virtual Bytes getBytes(unsigned int colIndex) = 0; + + virtual Date getDate(unsigned int colIndex) = 0; + + virtual Timestamp getTimestamp(unsigned int colIndex) = 0; + + virtual Bytes getRowid(unsigned int colIndex) = 0; + + virtual PObject * getObject(unsigned int colIndex) = 0; + + virtual Blob getBlob(unsigned int colIndex) = 0; + + virtual Clob getClob(unsigned int colIndex) =0; + + virtual Bfile getBfile(unsigned int colIndex) = 0; + + virtual IntervalYM getIntervalYM(unsigned int colIndex) =0; + + virtual IntervalDS getIntervalDS(unsigned int colIndex) =0; + + virtual RefAny getRef(unsigned int colIndex) = 0; + + virtual Bytes getRowPosition() const = 0; + + virtual ResultSet * getCursor(unsigned int colIndex) = 0; + + virtual void setDataBuffer(unsigned int colIndex, void *buffer, Type type, + sb4 size = 0, ub2 *length = NULL, + sb2 *ind = NULL, ub2 *rc = NULL) = 0; + + virtual void setCharSet(unsigned int colIndex, + const OCCI_STD_NAMESPACE::string & charSet) = 0; + + virtual OCCI_STD_NAMESPACE::string getCharSet(unsigned int colIndex) + const = 0; + + virtual void setBinaryStreamMode(unsigned int colIndex, unsigned int size) + = 0; + + virtual void setCharacterStreamMode(unsigned int colIndex, unsigned int size) + = 0; + + virtual void setDatabaseNCHARParam(unsigned int paramIndex, + bool isNCHAR) = 0; + + virtual bool getDatabaseNCHARParam(unsigned int paramIndex) const = 0; + + virtual Stream * getStream(unsigned int colIndex) = 0; + + virtual void closeStream(Stream *stream) =0; + + virtual unsigned int getCurrentStreamColumn() const= 0; + + virtual unsigned int getCurrentStreamRow() const= 0; + + virtual OCCI_STD_NAMESPACE::vector getColumnListMetaData() const + = 0; + + virtual Statement* getStatement() const=0; + + //new interfaces + + virtual BFloat getBFloat(unsigned int colIndex) = 0; + + virtual BDouble getBDouble(unsigned int colIndex) = 0; + + virtual UString getUString(unsigned int colIndex) = 0; + + virtual void setCharSetUString(unsigned int colIndex, + const UString & charSet) = 0; + + virtual UString getCharSetUString(unsigned int colIndex) + const = 0; + + virtual void setPrefetchRowCount(unsigned int rowCount) = 0; + + virtual void setPrefetchMemorySize(unsigned int bytes) = 0; +}; + + +class Stream +{ + public : + + enum Status {READY_FOR_READ, READY_FOR_WRITE, INACTIVE}; + + virtual ~Stream(){} + virtual int readBuffer(char *buffer, unsigned int size) + =0; + virtual int readLastBuffer(char *buffer, unsigned int size) + =0; + virtual void writeBuffer(char *buffer, unsigned int size) + =0; + virtual void writeLastBuffer(char *buffer, unsigned int size) + =0; + virtual Status status() const =0; + +}; + +/*--------------------------------------------------------------------------- + PROTOTYPES USED BY FUNCTION TEMPLATES + -------------------------------------------------------------------------*/ + void getVectorOfPObjects( ResultSet *rs, unsigned int index, + OCCI_STD_NAMESPACE::vector &vect) ; + void getVectorOfOCIRefs(ResultSet *rs, unsigned int index, + OCCI_STD_NAMESPACE::vector &vect) ; + void getVectorOfPObjects( Statement *rs, unsigned int index, + OCCI_STD_NAMESPACE::vector &vect) ; + void getVectorOfOCIRefs(Statement *rs, unsigned int index, + OCCI_STD_NAMESPACE::vector &vect) ; + void setVectorOfPObjects( Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const OCCI_STD_NAMESPACE::string &sqltype) ; + void setVectorOfPObjects( Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const OCCI_STD_NAMESPACE::string &schemaName, + const OCCI_STD_NAMESPACE::string &typeName) ; + void setVectorOfPObjects( Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const UString &schemaName, + const UString &typeName) ; + void setVectorOfOCIRefs(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const OCCI_STD_NAMESPACE::vector &vecind, + const OCCI_STD_NAMESPACE::string &sqltype) ; + void setVectorOfOCIRefs(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const OCCI_STD_NAMESPACE::vector &vecind, + const OCCI_STD_NAMESPACE::string &schemaName, + const OCCI_STD_NAMESPACE::string &typeName) ; + void setVectorOfOCIRefs(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + const OCCI_STD_NAMESPACE::vector &vecind, + const UString &schemaName, + const UString &typeName) ; + void pinVectorOfOCIRefs(const Connection *conn, + OCCI_STD_NAMESPACE::vector & vecRef, + OCCI_STD_NAMESPACE::vector & vecCor, + OCCI_STD_NAMESPACE::vector &vecPObj,LockOptions &lockOpt ); + + +/*--------------------------------------------------------------------------- + EXPORT FUNCTIONS + ---------------------------------------------------------------------------*/ + +/*------------------------ getVector for objects ---------------------------*/ +/* + NAME + getVector - overloaded function. Retrieves the attribute in the current +position as a vector of objects + + PARAMETERS + rs - ResultSet + vect- reference to vector of objects(OUT parameter). + + DESCRIPTION + Retrieves the column in the specified position as a vector of RefAny. + The attribute at the current position should be a collection type (varray or + nested table). The SQL type of the elements in the collection should be + compatible with objects. + + RETURNS + nothing + + NOTES + compatible SQL types : NTY + + will call getVector(..., vector) +*/ +#if defined(WIN32COMMON) || defined(__MVS__) +// and other platforms that do not support +// partial function template specialization + +template +void getVector( ResultSet *rs, unsigned int index,OCCI_STD_NAMESPACE::vector +& vect) +{ + OCCI_STD_NAMESPACE::vector vec_pobj; + getVectorOfPObjects(rs, index, vec_pobj); + + vect.clear(); + unsigned int size = vec_pobj.size(); + vect.reserve( size ); + for ( unsigned int i=0; i< size; i++) + vect.push_back((T)vec_pobj[i]); +} + +#else +template +void getVector( ResultSet *rs, unsigned int index, OCCI_STD_NAMESPACE::vector &vect) +{ + OCCI_STD_NAMESPACE::vector vec_pobj; + getVectorOfPObjects(rs, index, vec_pobj); + + vect.clear(); + unsigned int size = vec_pobj.size(); + vect.reserve( size ); + for (unsigned int i=0; i< size; i++) + vect.push_back((T *)vec_pobj[i]); +} +#endif + +/*------------------------ getVector for objects ---------------------------*/ +/* + NAME + getVector - overloaded function. Retrieves the attribute in the current +position as a vector of objects + + PARAMETERS + stmt - Statement + vect- reference to vector of objects(OUT parameter). + + DESCRIPTION + Retrieves the column in the specified position as a vector of RefAny. + The attribute at the current position should be a collection type (varray or + nested table). The SQL type of the elements in the collection should be + compatible with objects. + + RETURNS + nothing + + NOTES + compatible SQL types : NTY + + will call getVector(..., vector) +*/ +#if defined(WIN32COMMON) || defined(__MVS__) +// and other platforms that do not support +// partial function template specialization + +template +void getVector( Statement *stmt, unsigned int index, +OCCI_STD_NAMESPACE::vector &vect) +{ + OCCI_STD_NAMESPACE::vector vec_pobj; + getVectorOfPObjects(stmt, index, vec_pobj); + vect.clear(); + unsigned int size = vec_pobj.size(); + vect.reserve( size ); + for (unsigned int i=0; i< size; i++) + vect.push_back((T)vec_pobj[i]); +} +#else +template +void getVector( Statement *stmt, unsigned int index, +OCCI_STD_NAMESPACE::vector &vect) +{ + OCCI_STD_NAMESPACE::vector vec_pobj; + getVectorOfPObjects(stmt, index, vec_pobj); + vect.clear(); + unsigned int size = vec_pobj.size(); + vect.reserve( size ); + for (unsigned int i=0; i< size; i++) + vect.push_back((T *)vec_pobj[i]); +} +#endif + +/*------------------------ getVector for Ref ---------------------------*/ +/* + NAME + getVector - overloaded function. Retrieves the attribute in the current +position as a vector of Ref + + PARAMETERS + rs - ResultSet + vect- reference to vector of Ref(OUT parameter). + + DESCRIPTION + Retrieves the column in the specified position as a vector of Ref. + The attribute at the current position should be a collection type (varray or + nested table). The SQL type of the elements in the collection should be + compatible with Ref. + + RETURNS + nothing + + NOTES + compatible SQL types : REF +*/ +#if !defined(WIN32COMMON) && !defined(__MVS__) +template +void getVector( ResultSet *rs, unsigned int index, + OCCI_STD_NAMESPACE::vector > &vect) +{ + OCCI_STD_NAMESPACE::vector vec_ref; + getVectorOfOCIRefs(rs, index, vec_ref); + + const Connection *sess = rs->getStatement()->getConnection(); + + vect.clear(); + unsigned int size = vec_ref.size(); + vect.reserve( size ); + for (unsigned int i=0; i< size; i++) + { + if (vec_ref[i] == (OCIRef *)0) + vect.push_back(Ref()); // pushing a default-constructed Ref + else + vect.push_back(Ref(sess, (OCIRef *)vec_ref[i], FALSE)); + } +} +#endif + +/*------------------------ setVector for PObject*---------------------------*/ +/* + NAME + SetVector - overloaded function. Binds the attribute in the current + position with a vector of objects. + + PARAMETERS + rs - ResultSet + vect- reference to vector of objects(OUT parameter). + + DESCRIPTION + Binds the column in the specified position with a vector of signed int . + The column at the current position should be a collection type (varray or + nested table). The SQL type of the elements in the collection should be + compatible with objects . + + RETURNS + nothing + + NOTES + compatible SQL types : SQLT_NTY + + This will be calling setVector(..., vector,..) + +*/ +#if defined(WIN32COMMON) || defined(__MVS__) +// and other platforms that do not support +// partial function template specialization + +template +void setVector( Statement *stmt, unsigned int index, + const OCCI_STD_NAMESPACE::vector &vect, + const OCCI_STD_NAMESPACE::string &sqltype) +{ + OCCI_STD_NAMESPACE::vector vec_pobj; + unsigned int size = vect.size(); + vec_pobj.reserve( size ); + + for (unsigned int i = 0; i < size; i++) + vec_pobj.push_back((PObject *)vect[i]); + + setVectorOfPObjects(stmt, index, vec_pobj, sqltype); +} + +template +void setVector( Statement *stmt, unsigned int index, const OCCI_STD_NAMESPACE:: +vector &vect, const OCCI_STD_NAMESPACE::string &schemaName, +const OCCI_STD_NAMESPACE::string &typeName) +{ + OCCI_STD_NAMESPACE::vector vec_pobj; + unsigned int size = vect.size(); + vec_pobj.reserve( size ); + + for (unsigned int i = 0; i < size; i++) + vec_pobj.push_back((PObject *)vect[i]); + + setVectorOfPObjects(stmt, index, vec_pobj, schemaName, typeName); +} + +template +void setVector( Statement *stmt, unsigned int index, const OCCI_STD_NAMESPACE:: +vector &vect, const UString &schemaName, +const UString &typeName) +{ + OCCI_STD_NAMESPACE::vector vec_pobj; + unsigned int size = vect.size(); + vec_pobj.reserve( size ); + + for (unsigned int i = 0; i < size; i++) + vec_pobj.push_back((PObject *)vect[i]); + + setVectorOfPObjects(stmt, index, vec_pobj, schemaName, typeName); +} +#else +template +void setVector( Statement *stmt, unsigned int index, const OCCI_STD_NAMESPACE:: +vector &vect, const OCCI_STD_NAMESPACE::string &sqltype) +{ + OCCI_STD_NAMESPACE::vector vec_pobj; + unsigned int size = vect.size(); + vec_pobj.reserve( size ); + + for (unsigned int i = 0; i < size; i++) + vec_pobj.push_back((PObject *)vect[i]); + + setVectorOfPObjects(stmt, index, vec_pobj, sqltype); +} + +template +void setVector( Statement *stmt, unsigned int index, const OCCI_STD_NAMESPACE:: +vector &vect, const OCCI_STD_NAMESPACE::string &schemaName, +const OCCI_STD_NAMESPACE::string &typeName) +{ + OCCI_STD_NAMESPACE::vector vec_pobj; + unsigned int size = vect.size(); + vec_pobj.reserve( size ); + + for (unsigned int i = 0; i < size; i++) + vec_pobj.push_back((PObject *)vect[i]); + + setVectorOfPObjects(stmt, index, vec_pobj, schemaName, typeName); +} + +template +void setVector( Statement *stmt, unsigned int index, const OCCI_STD_NAMESPACE:: +vector &vect, const UString &schemaName, +const UString &typeName) +{ + OCCI_STD_NAMESPACE::vector vec_pobj; + unsigned int size = vect.size(); + vec_pobj.reserve( size ); + + for (unsigned int i = 0; i < size; i++) + vec_pobj.push_back((PObject *)vect[i]); + + setVectorOfPObjects(stmt, index, vec_pobj, schemaName, typeName); +} +#endif + +/*------------------------ setVector for Ref---------------------------*/ +/* + NAME + setVector - overloaded function. Binds the attribute in the current + position with a vector of Ref. + + PARAMETERS + rs - ResultSet + vect- reference to vector of REF + + DESCRIPTION + Binds the column in the specified position with a vector of signed int . + The column at the current position should be a collection type (varray or + nested table). The SQL type of the elements in the collection should be + compatible with OCIRef* . + + RETURNS + nothing + + NOTES + compatible SQL types : REF + + This will just call setVector(..., vector,..) + + +*/ +#if !defined(WIN32COMMON) && !defined(__MVS__) +template +void setVector( Statement *stmt, unsigned int index, + const OCCI_STD_NAMESPACE::vector > &vect, + const OCCI_STD_NAMESPACE::string &sqltype) +{ + OCCI_STD_NAMESPACE::vector vec_ref; + OCCI_STD_NAMESPACE::vector vec_ind; + unsigned int size = vect.size(); + vec_ref.reserve( size ); + vec_ind.reserve( size ); + + for (unsigned int i = 0; i < size; i++) + { + vec_ref.push_back((void *)vect[i].getRef()); + vec_ind.push_back( vect[i].isNull() ? OCI_IND_NULL : OCI_IND_NOTNULL); + } + + setVectorOfOCIRefs(stmt, index, vec_ref, vec_ind, sqltype); +} + +template +void setVector( Statement *stmt, unsigned int index, + const OCCI_STD_NAMESPACE::vector > &vect, + const OCCI_STD_NAMESPACE::string &schemaName, + const OCCI_STD_NAMESPACE::string &typeName) +{ + OCCI_STD_NAMESPACE::vector vec_ref; + OCCI_STD_NAMESPACE::vector vec_ind; + unsigned int size = vect.size(); + vec_ref.reserve( size ); + vec_ind.reserve( size ); + + for (unsigned int i = 0; i < size; i++) + { + vec_ref.push_back((void *)vect[i].getRef()); + vec_ind.push_back( vect[i].isNull() ? OCI_IND_NULL : OCI_IND_NOTNULL); + } + + setVectorOfOCIRefs(stmt, index, vec_ref, vec_ind, schemaName, typeName); +} + +template +void setVector( Statement *stmt, unsigned int index, + const OCCI_STD_NAMESPACE::vector > &vect, + const UString &schemaName, + const UString &typeName) +{ + OCCI_STD_NAMESPACE::vector vec_ref; + OCCI_STD_NAMESPACE::vector vec_ind; + unsigned int size = vect.size(); + vec_ref.reserve( size ); + vec_ind.reserve( size ); + + for (unsigned int i = 0; i < size; i++) + { + vec_ref.push_back((void *)vect[i].getRef()); + vec_ind.push_back( vect[i].isNull() ? OCI_IND_NULL : OCI_IND_NOTNULL); + } + + setVectorOfOCIRefs(stmt, index, vec_ref, vec_ind, schemaName, typeName); +} +#endif + +/*------------------------ getVector for Ref ---------------------------*/ +/* + NAME + getVector - overloaded function. Retrieves the attribute in the current +position as a vector of Ref + + PARAMETERS + stmt - Statement + vect- reference to vector of Ref(OUT parameter). + + DESCRIPTION + Retrieves the column in the specified position as a vector of Ref. + The attribute at the current position should be a collection type (varray or + nested table). The SQL type of the elements in the collection should be + compatible with Ref. + + RETURNS + nothing + + NOTES + compatible SQL types : REF +*/ +#if !defined(WIN32COMMON) && !defined(__MVS__) +template +void getVector( Statement *stmt, unsigned int index, + OCCI_STD_NAMESPACE::vector > &vect) +{ + OCCI_STD_NAMESPACE::vector vec_ref; + getVectorOfOCIRefs(stmt, index, vec_ref); + + const Connection *sess = stmt->getConnection(); + + vect.clear(); + unsigned int size = vec_ref.size(); + vect.reserve( size ); + for (unsigned int i=0; i< size; i++) + { + if (vec_ref[i] == (OCIRef *)0) + vect.push_back(Ref ()); // pushing a default-constructed Ref + else + vect.push_back(Ref (sess, (OCIRef *)vec_ref[i], FALSE)); + } + +} +#endif + +// Platform independent get/setVectorOfRefs method added +// get(set)Vector of Ref and get(set)VectorOfRefs are identical +// in functionality. + +/*------------------------ getVectorOfRefs for Ref ----------------------*/ +/* + NAME + getVectorOfRefs - overloaded function. Retrieves the attribute in the + current position as a vector of Ref + + PARAMETERS + rs - ResultSet + vect- reference to vector of Ref(OUT parameter). + + DESCRIPTION + Retrieves the column in the specified position as a vector of Ref. + The attribute at the current position should be a collection type (varray or + nested table). The SQL type of the elements in the collection should be + compatible with Ref. + + RETURNS + nothing + + NOTES + compatible SQL types : REF +*/ + +template +void getVectorOfRefs( ResultSet *rs, unsigned int index, +OCCI_STD_NAMESPACE::vector > &vect) +{ + OCCI_STD_NAMESPACE::vector vec_ref; + getVectorOfOCIRefs(rs, index, vec_ref); + + const Connection *sess = rs->getStatement()->getConnection(); + + vect.clear(); + unsigned int size = vec_ref.size(); + vect.reserve( size ); + for (unsigned int i=0; i< size; i++) + { + if (vec_ref[i] == (OCIRef *)0) + vect.push_back(Ref()); // pushing a default-constructed Ref + else + vect.push_back(Ref(sess, (OCIRef *)vec_ref[i], FALSE)); + } +} + +/*------------------------ setVectorOfRefs for Ref-----------------------*/ +/* + NAME + setVectorOfRefs - overloaded function. Binds the attribute in the current + position with a vector of Ref. + + PARAMETERS + rs - ResultSet + vect- reference to vector of REF + + DESCRIPTION + Binds the column in the specified position with a vector of signed int . + The column at the current position should be a collection type (varray or + nested table). The SQL type of the elements in the collection should be + compatible with OCIRef* . + + RETURNS + nothing + + NOTES + compatible SQL types : REF + + This will just call setVector(..., vector,..) + + +*/ + +template +void setVectorOfRefs( Statement *stmt, unsigned int index, +const OCCI_STD_NAMESPACE::vector > &vect, +const OCCI_STD_NAMESPACE::string &sqltype) +{ + OCCI_STD_NAMESPACE::vector vec_ref; + OCCI_STD_NAMESPACE::vector vec_ind; + unsigned int size = vect.size(); + vec_ref.reserve( size ); + vec_ind.reserve( size ); + + for (unsigned int i = 0; i < size; i++) + { + vec_ref.push_back((void *)vect[i].getRef()); + vec_ind.push_back( vect[i].isNull() ? OCI_IND_NULL : OCI_IND_NOTNULL); + } + + setVectorOfOCIRefs(stmt, index, vec_ref, vec_ind, sqltype); +} + +template +void setVectorOfRefs( Statement *stmt, unsigned int index, +const OCCI_STD_NAMESPACE::vector > &vect, +const OCCI_STD_NAMESPACE::string &schemaName, +const OCCI_STD_NAMESPACE::string &typeName) +{ + OCCI_STD_NAMESPACE::vector vec_ref; + OCCI_STD_NAMESPACE::vector vec_ind; + unsigned int size = vect.size(); + vec_ref.reserve( size ); + vec_ind.reserve( size ); + + for (unsigned int i = 0; i < size; i++) + { + vec_ref.push_back((void *)vect[i].getRef()); + vec_ind.push_back( vect[i].isNull() ? OCI_IND_NULL : OCI_IND_NOTNULL); + } + + setVectorOfOCIRefs(stmt, index, vec_ref, vec_ind, schemaName, typeName); +} + +template +void setVectorOfRefs( Statement *stmt, unsigned int index, +const OCCI_STD_NAMESPACE::vector > &vect, +const UString &schemaName, +const UString &typeName) +{ + OCCI_STD_NAMESPACE::vector vec_ref; + OCCI_STD_NAMESPACE::vector vec_ind; + unsigned int size = vect.size(); + vec_ref.reserve( size ); + vec_ind.reserve( size ); + + for (unsigned int i = 0; i < size; i++) + { + vec_ref.push_back((void *)vect[i].getRef()); + vec_ind.push_back( vect[i].isNull() ? OCI_IND_NULL : OCI_IND_NOTNULL); + } + + setVectorOfOCIRefs(stmt, index, vec_ref, vec_ind, schemaName, typeName); +} + +/*------------------------ getVectorOfRefs for Ref ----------------------*/ +/* + NAME + getVectorOfRefs - overloaded function. Retrieves the attribute in the + current position as a vector of Ref + + PARAMETERS + stmt - Statement + vect- reference to vector of Ref(OUT parameter). + + DESCRIPTION + Retrieves the column in the specified position as a vector of Ref. + The attribute at the current position should be a collection type (varray or + nested table). The SQL type of the elements in the collection should be + compatible with Ref. + + RETURNS + nothing + + NOTES + compatible SQL types : REF +*/ + +template +void getVectorOfRefs( Statement *stmt, unsigned int index, +OCCI_STD_NAMESPACE::vector > &vect) +{ + OCCI_STD_NAMESPACE::vector vec_ref; + getVectorOfOCIRefs(stmt, index, vec_ref); + + const Connection *sess = stmt->getConnection(); + + vect.clear(); + unsigned int size = vec_ref.size(); + vect.reserve( size ); + for (unsigned int i=0; i< size; i++) + { + if (vec_ref[i] == (OCIRef *)0) + vect.push_back(Ref ()); // pushing a default-constructed Ref + else + vect.push_back(Ref (sess, (OCIRef *)vec_ref[i], FALSE)); + } +} +/*----------------------------- pinVectorOfRefs---------------------*/ +/* + NAME + pinVectorOfRefs - array pin implementation + + PARAMETERS + conn- Connection object + vecRef - vector of OCIRefs * + vecCor - vector of OCIComplexObject * + vecPOBj - vector of PObject * ( OUT ) + + DESCRIPTION + implements the array pin of refs passed and returns the corresponding + PObject s + + RETURNS + + NOTES +*/ +template +void pinVectorOfRefs( const Connection *conn, +OCCI_STD_NAMESPACE::vector > &vect, +OCCI_STD_NAMESPACE::vector &vectObj, LockOptions lockOpt) +{ + + OCCI_STD_NAMESPACE::vector vecRef; + OCCI_STD_NAMESPACE::vector vecCor; + OCCI_STD_NAMESPACE::vector vecPObj; + unsigned int sz = vect.size(); + vecRef.reserve( sz ); + vecCor.reserve( sz ); + + for ( unsigned int i=0; i < sz; i++) + { + vecRef.push_back((void *)vect[i].getRef()); + vecCor.push_back((void *)vect[i].getCor()); + } + pinVectorOfOCIRefs(conn, vecRef, vecCor, vecPObj, lockOpt); + for ( unsigned int k=0; k < sz; k++) + { + vectObj.push_back((T *)vecPObj[k]); + vect[k].setPinnedObject(vecPObj[k]); + } +} + +/*----------------------------- pinVectorOfRefs---------------------*/ +/* + NAME + pinVectorOfRefs - array pin implementation + + PARAMETERS + conn- Connection object + vecRef - vector of OCIRefs * + vecCor - vector of OCIComplexObject * + + DESCRIPTION + implements the array pin of refs passed + + RETURNS + + NOTES +*/ +template +void pinVectorOfRefs( const Connection *conn, +OCCI_STD_NAMESPACE::vector > &vect, +LockOptions lockOpt) +{ + + OCCI_STD_NAMESPACE::vector vecRef; + OCCI_STD_NAMESPACE::vector vecCor; + OCCI_STD_NAMESPACE::vector vecPObj; + unsigned int sz = vect.size(); + vecRef.reserve( sz ); + vecCor.reserve( sz ); + + for ( unsigned int i=0; i < sz; i++) + { + vecRef.push_back((void *)vect[i].getRef()); + vecCor.push_back((void *)vect[i].getCor()); + } + pinVectorOfOCIRefs(conn, vecRef, vecCor,vecPObj, lockOpt); + for ( unsigned int k=0; k < sz; k++) + vect[k].setPinnedObject(vecPObj[k]); +} + + + +/*--------------------------------------------------------------------------- + INTERNAL FUNCTIONS + ---------------------------------------------------------------------------*/ + + +} /* end of namespace occi */ +} /* end of namespace oracle */ +#endif /* OCCICONTROL_ORACLE */ + +#endif /* _olint */ diff --git a/OCI/include/occiData.h b/OCI/include/occiData.h new file mode 100644 index 0000000..cd50673 --- /dev/null +++ b/OCI/include/occiData.h @@ -0,0 +1,1167 @@ +/* Copyright (c) 2000, 2008, Oracle. All rights reserved. */ + +/* + NAME + occiData.h - header file for OCCI data classes + + DESCRIPTION + Class definitions for Stream, Blob, Clob ,Bfile, + Number, Date, IntervalYM, IntervalDS, Time, + Timestamp + + RELATED DOCUMENTS + + + EXPORT FUNCTION(S) + + + INTERNAL FUNCTION(S) + + + EXAMPLES + + NOTES + + + MODIFIED (MM/DD/YY) + slynn 03/18/08 - Add get/setContentType. + slynn 09/14/06 - Remove string.clear() + slynn 07/28/06 - Migrate to new 11g LOB terminology + slynn 06/21/06 - Add LobRegion + slynn 05/25/06 - New NG Lob Functionality. + cparampa 09/06/04 - Date changes + shiyer 10/31/03 - Timestamp constructors issue + rvallam 10/07/03 - bug 3089939 - add private method in Date to compute + hour and min component in daysBetween to be passed + to set method of IntervalDS. + cparampa 08/21/03 - added toCopy to IntervalDS and IntervalYM + cparampa 07/14/03 - make SubscriptionImpl friend of Bytes class. + rvallam 02/12/03 - modified BFloat/BDouble interface - BFloat/BDouble + type is now a struct + cparampa 01/20/03 - made ProducerImpl friend of Bytes class + rvallam 11/19/02 - objects support for interval class + shiyer 11/15/02 - Add UTF16 support to IntervalYM & IntervalDS + cparampa 12/11/02 - removed references to class Payload + cparampa 10/12/02 - AQ additions + shiyer 10/12/02 - Added UTF16 version of get/set CharsetId in Clob + shiyer 09/06/02 - OCCI globalization support + aahluwal 06/04/02 - bug 2360115 + vvinay 02/21/02 - operator= added for Bytes + gayyappa 10/23/01 - fix bug 2073327 , use string instead of + enum CharSet + vvinay 12/21/01 - signed char constructor and cast operator + (bug 2073334) + binary operator methods not friends any more + gayyappa 15/10/01 - add parameter toCopy to Lob/Timestamp private + constructors + rvallam 04/09/01 - change private constructor in Number to pass + parameter by reference and made it const + chliang 03/05/01 - disable olint + rvallam 01/27/02 - remove #include + gayyappa 01/17/01 - add methods/operators to Interval and + timestamp classes.. + gayyappa 12/15/00 - interface changes in set methods + rvallam 11/29/00 - change method signature in Bytes + added 3 new methods in Number + rvallam 10/20/00 - change method signatures in Date + rvallam 09/15/00 - make StmtImpl/ResultSetImpl friend to + interval classes + gayyappa 08/21/00 - modified timestamp, interval headers. + add OCIEnv to constructor of Bytes., + removed getOCIRaw from Bytes. + add const to setVector mthds of anydata. + add void* data member to Timestamp/Interval. + rvallam 08/10/00 - modified CORE class headers to add friends , + added private constructor in Bytes + slari 08/02/00 - comment out Stream + rratnam 08/04/00 - updated the LOB stream interface + rkasamse 08/07/00 - make getVector friend of Time + slari 07/31/00 - add const to Bytes methods + slari 07/25/00 - disable Bytes(Bytes *) + slari 07/23/00 - add Bytes + gayyappa 07/26/00 - update Timestamp, IntervalYM, IntervalDS. + gayyappa 07/04/00 - for fixing a problem in occiNumber + rratnam 06/13/00 - Updated LOB class headers + kmohan 05/31/00 - Change Environment to Environment * in + Date constructor + kmohan 05/29/00 - No string + rkasamse 04/25/00 - Added string class header + etucker 04/19/00 - Added CORE class headers + kmohan 04/11/00 - Creation + +*/ + +#ifndef _olint /* disable olint check */ + +#ifndef OCCIDATA_ORACLE +# define OCCIDATA_ORACLE + +#ifndef OCCICOMMON_ORACLE +#include +#endif + +#ifndef OCCICONTROL_ORACLE +#include +#endif + +namespace oracle { +namespace occi { +class Bytes +{ + + public: + + Bytes(const Environment *env = NULL); // default constructor + + Bytes(unsigned char *value, unsigned int count, + unsigned int offset = 0, const Environment *env = NULL); + + Bytes(const Bytes &e); // copy constructor + + + // public methods + + void getBytes(unsigned char *dst, unsigned int count, + unsigned int srcBegin = 0, + unsigned int dstBegin = 0) const; + + unsigned int length() const; + + unsigned char byteAt(unsigned int index) const; + + bool isNull() const; + + void setNull(); + + void operator=(const Bytes &other); + + ~Bytes(); + +private: + // private data members + Bytes(OCIEnv *,OCIRaw *) ; + Bytes(Ptr bytesPtr) ; + Ptr ptr_; + friend class AnyDataImpl; + friend class aq::MessageImpl; + friend class aq::ProducerImpl; + friend class aq::SubscriptionImpl; + friend void getVector(const AnyData &any, + OCCI_STD_NAMESPACE::vector &vect) ; + friend void setVector(AnyData &any, + const OCCI_STD_NAMESPACE::vector &vect) ; + +}; + +class Bfile +{ + public : + + Bfile(); + Bfile(const Connection *connectionp) ; + Bfile(const Bfile &srcBfile) ; + ~Bfile(); + unsigned int length() const ; + OCCI_STD_NAMESPACE::string getDirAlias() const ; + UString getUStringDirAlias() const ; + OCCI_STD_NAMESPACE::string getFileName() const ; + UString getUStringFileName() const ; + void setName(const OCCI_STD_NAMESPACE::string &dirAlias, + const OCCI_STD_NAMESPACE::string &fileName) ; + void setName(const UString &dirAlias, const UString &fileName) ; + bool fileExists() const ; + Bfile& operator =(const Bfile &srcBfile) ; + bool operator ==(const Bfile &srcBfile) const ; + bool operator !=(const Bfile &srcBfile) const ; + void setNull() ; + bool isNull() const ; + bool isInitialized() const; + void open() ; + void close() ; + bool isOpen() const ; + unsigned int read(unsigned int amt, unsigned char *buffer, + unsigned int bufsize, unsigned int offset = 1) const ; + Stream* getStream(unsigned int offset = 1, + unsigned int amount =0) ; + void closeStream(Stream *stream); + + private: + + //Data Members: + + // pointer to the FILE locator + OCIBFileLocator *filep; + + // pointer to the ConnectionImpl instance + const ConnectionImpl *connp; + + // pointer to the LobStreamImpl instance obtained from this FILE + LobStreamImpl *streamp; + + void *bfileExt; + + //Enumerations: + enum {MAXDIRNAMELEN = 32, MAXFILENAMELEN = 256}; + + //Constructor: + Bfile(const Connection *connectionp, + OCIBFileLocator *locatorp, bool toCopy = true) ; + + //Methods: + OCIBFileLocator* getLocator() const; + void do_getDirAlias( void * dirAlias, ub2 * dirAliasLen) const ; + void do_getFileName( void * fileName, ub2 * fileNameLen) const ; + void do_setName( void * alias, ub2 aliasLen, + void *fileName, ub2 fileNameLen); + // Friends + friend class AnyDataImpl; + friend class StatementImpl; + friend class ResultSetImpl; + friend class Blob; + friend class Clob; + friend class aq::MessageImpl; + + friend void getVector(const AnyData&, OCCI_STD_NAMESPACE::vector&) ; + friend void getVector(Statement*, unsigned int, + OCCI_STD_NAMESPACE::vector&) ; + friend void getVector(ResultSet*, unsigned int , + OCCI_STD_NAMESPACE::vector&) ; + friend void setVector(AnyData&, const OCCI_STD_NAMESPACE::vector&) ; + friend void do_setVectorOfBfile(Statement*, unsigned int, + const OCCI_STD_NAMESPACE::vector&, void *, unsigned int, + void *, unsigned int ) ; + +#ifdef ORAXB8_DEFINED + friend void readVectorOfBfiles(const Connection *conn, + OCCI_STD_NAMESPACE::vector &vec, + oraub8 *byte_amts, oraub8 *offsets, + unsigned char *buffers[], oraub8 *buffer_lens); +#endif +}; + + +#ifdef ORAXB8_DEFINED +// See the end of this file for implementation of LobRegion +template < typename lobType > class LobRegion +{ + private: + lobType *_primary; + oraub8 _primaryOffset; + oraub8 _offset; + oraub8 _length; + OCCI_STD_NAMESPACE::string _mimeType; + + void setPrimary(const ConnectionImpl *connp, + OCILobLocator *locator); + + public: + LobRegion(); + ~LobRegion(); + lobType *getPrimary(); + oraub8 getPrimaryOffset(); + oraub8 getOffset(); + oraub8 getLength(); + OCCI_STD_NAMESPACE::string getMimeType(); + + friend class Blob; + friend class Clob; +}; + +typedef LobRegion BlobRegion; +typedef LobRegion ClobRegion; +#endif + + +class Blob +{ + public: + + Blob(); + Blob(const Connection *connectionp) ; + Blob(const Blob &srcBlob) ; + ~Blob(); + unsigned int getChunkSize() const ; + unsigned int length() const ; + Blob& operator =(const Blob &srcBlob) ; + bool operator ==(const Blob &srcBlob) const ; + bool operator !=(const Blob &srcBlob) const ; + void setNull() ; + bool isNull() const ; + void setEmpty() ; + void setEmpty(const Connection *connectionp) ; + bool isInitialized() const; + void open(LobOpenMode mode=OCCI_LOB_READWRITE) ; + void close() ; + bool isOpen() const ; + void copy(const Blob &srcBlob, unsigned int numBytes, + unsigned int dstOffset =1, unsigned int srcOffset =1) ; + void copy(const Bfile &srcBfile, unsigned int numBytes, + unsigned int dstOffset =1, unsigned int srcOffset =1) ; + void append(const Blob &srcBlob) ; + unsigned int read(unsigned int amt, unsigned char *buffer, + unsigned int bufsize, unsigned int offset = 1) const ; + unsigned int write(unsigned int amt, unsigned char *buffer, + unsigned int bufsize, unsigned int offset = 1) ; + unsigned int writeChunk(unsigned int amt, unsigned char *buffer, + unsigned int bufsize, unsigned int offset = 1) ; + void trim(unsigned int newlen) ; + Stream* getStream(unsigned int offset = 1, + unsigned int amount =0) ; + void closeStream(Stream *stream); + LobOptionValue getOptions(LobOptionType optType); + void setOptions(LobOptionType optType, LobOptionValue value); + OCCI_STD_NAMESPACE::string getContentType(void); + void setContentType(const OCCI_STD_NAMESPACE::string contentType); + + void getDeduplicateRegions(OCCI_STD_NAMESPACE::vector ®ions); + private: + + //Data Members: + + // pointer to the BLOB locator + OCIBlobLocator *lobp; + + // pointer to the ConnectionImpl instance + const ConnectionImpl *connp; + + // pointer to the LobStreamImpl instance obtained from this LOB + LobStreamImpl *streamp; + + //for future use ! + void *blobExt; + + //Constructor: + Blob(const Connection *connectionp, + OCIBlobLocator *locatorp, bool toCopy=true) ; + + //Methods: + OCIBlobLocator* getLocator() const; + + // Friends + friend class AnyDataImpl; + friend class StatementImpl; + friend class ResultSetImpl; + +#ifdef ORAXB8_DEFINED + friend void + LobRegion::setPrimary(const ConnectionImpl *connp, + OCILobLocator *locator); +#endif + friend void getVector(const AnyData&, OCCI_STD_NAMESPACE::vector&) ; + friend void getVector(Statement*, unsigned int, + OCCI_STD_NAMESPACE::vector&) ; + friend void getVector(ResultSet*, unsigned int, + OCCI_STD_NAMESPACE::vector&) ; + friend void setVector(AnyData&, const OCCI_STD_NAMESPACE::vector&) ; + friend void do_setVectorOfBlob(Statement*, unsigned int, + const OCCI_STD_NAMESPACE::vector&, void *, + unsigned int, void *, unsigned int ) ; +#ifdef ORAXB8_DEFINED + friend void readVectorOfBlobs(const Connection *conn, + OCCI_STD_NAMESPACE::vector &vec, + oraub8 *byte_amts, oraub8 *offsets, + unsigned char *buffers[], oraub8 *buffer_lens); + friend void writeVectorOfBlobs(const Connection *conn, + OCCI_STD_NAMESPACE::vector &vec, + oraub8 *byte_amts, oraub8 *offsets, + unsigned char *buffers[], oraub8 *buffer_lens); +#endif +}; + +class Clob +{ + public: + + Clob(); + Clob(const Connection *connectionp) ; + Clob(const Clob &srcClob) ; + ~Clob(); + unsigned int getChunkSize() const ; + unsigned int length() const ; + OCCI_STD_NAMESPACE::string getCharSetId() const; + CharSetForm getCharSetForm() const; + void setCharSetId( const OCCI_STD_NAMESPACE::string &charset) ; + void setCharSetForm( CharSetForm csfrm) ; + Clob& operator =(const Clob &srcClob) ; + bool operator ==(const Clob &srcClob) const ; + bool operator !=(const Clob &srcClob) const ; + void setNull() ; + bool isNull() const ; + void setEmpty() ; + void setEmpty(const Connection *connectionp) ; + bool isInitialized() const; + void open(LobOpenMode mode=OCCI_LOB_READWRITE) ; + void close() ; + bool isOpen() const ; + void copy(const Clob &srcClob, unsigned int numBytes, + unsigned int dstOffset = 1, unsigned int srcOffset = 1) ; + void copy(const Bfile &srcBfile, unsigned int numBytes, + unsigned int dstOffset = 1, unsigned int srcOffset = 1) ; + void append(const Clob &srcClob) ; + unsigned int read(unsigned int amt, unsigned char *buffer, + unsigned int bufsize, unsigned int offset = 1) const; + unsigned int read(unsigned int amt, utext *buffer, + unsigned int bufsize, unsigned int offset = 1) const; + unsigned int write(unsigned int amt, unsigned char *buffer, + unsigned int bufsize, unsigned int offset = 1 ); + unsigned int write(unsigned int amt, utext *buffer, + unsigned int bufsize, unsigned int offset = 1 ); + unsigned int writeChunk(unsigned int amt, unsigned char *buffer, + unsigned int bufsize, unsigned int offset = 1 ); + unsigned int writeChunk(unsigned int amt, utext *buffer, + unsigned int bufsize, unsigned int offset = 1 ); + void trim(unsigned int newlen) ; + Stream* getStream(unsigned int offset = 1, + unsigned int amount =0 ); + void closeStream(Stream *stream); + LobOptionValue getOptions(LobOptionType optType); + void setOptions(LobOptionType optType, LobOptionValue value); + OCCI_STD_NAMESPACE::string getContentType(void); + void setContentType(const OCCI_STD_NAMESPACE::string contentType); + + UString getCharSetIdUString() const; + void setCharSetIdUString( const UString &charset) ; + + void getDeduplicateRegions(OCCI_STD_NAMESPACE::vector ®ions); + + private: + + //Data Members: + + // pointer to the CLOB locator + OCIClobLocator *lobp; + + // pointer to the ConnectionImpl instance + const ConnectionImpl *connp; + + // pointer to the LobStreamImpl instance obtained from this LOB + LobStreamImpl *streamp; + + //charset id + ub2 charsetId; + + //charset form + CharSetForm charsetForm; + + //for future use ! + void *clobExt; + + //Constructor: + Clob(const Connection *connectionp, + OCIClobLocator *locatorp, bool toCopy =true ) ; + + //Methods: + OCIClobLocator* getLocator() const; + unsigned int do_read( unsigned int amt, void *buffer, + unsigned int bufsize, unsigned int offset) const; + unsigned int do_write( unsigned int amt, void *buffer, + unsigned int bufsize, unsigned int offset) ; + unsigned int do_writeChunk( unsigned int amt, void *buffer, + unsigned int bufsize, unsigned int offset) ; + + // Friends + friend class AnyDataImpl; + friend class StatementImpl; + friend class ResultSetImpl; + +#ifdef ORAXB8_DEFINED + friend void + LobRegion::setPrimary(const ConnectionImpl *connp, + OCILobLocator *locator); +#endif + friend void getVector(const AnyData&, OCCI_STD_NAMESPACE::vector&) ; + friend void getVector(Statement*, unsigned int, + OCCI_STD_NAMESPACE::vector&) ; + friend void getVector(ResultSet*, unsigned int, + OCCI_STD_NAMESPACE::vector&) ; + friend void setVector(AnyData&, const OCCI_STD_NAMESPACE::vector&) ; + friend void do_setVectorOfClob(Statement*, unsigned int, + const OCCI_STD_NAMESPACE::vector&, void *, + unsigned int, void *, unsigned int ) ; +#ifdef ORAXB8_DEFINED + friend void readVectorOfClobs(const Connection *conn, + OCCI_STD_NAMESPACE::vector &vec, + oraub8 *byte_amts, oraub8 *char_amts, oraub8 *offsets, + unsigned char *buffers[], oraub8 *buffer_lens); + friend void writeVectorOfClobs(const Connection *conn, + OCCI_STD_NAMESPACE::vector &vec, + oraub8 *byte_amts, oraub8 *char_amts, oraub8 *offsets, + unsigned char *buffers[], oraub8 *buffer_lens); + friend void readVectorOfClobs(const Connection *conn, + OCCI_STD_NAMESPACE::vector &vec, + oraub8 *byte_amts, oraub8 *char_amts, oraub8 *offsets, + utext *buffers[], oraub8 *buffer_lens); + friend void writeVectorOfClobs(const Connection *conn, + OCCI_STD_NAMESPACE::vector &vec, + oraub8 *byte_amts, oraub8 *char_amts, oraub8 *offsets, + utext *buffers[], oraub8 *buffer_lens); +#endif +}; + +class Number +{ + + public: + + // Constructors + /* default constructor added */ + Number(); + Number(const Number &srcNum); + Number(long double val) ; + Number(double val) ; + Number(float val) ; + Number(long val) ; + Number(int val) ; + Number(short val) ; + Number(char val) ; + Number(signed char val); + Number(unsigned long val) ; + Number(unsigned int val) ; + Number(unsigned short val) ; + Number(unsigned char val) ; + + ~Number(); + // Methods + const Number abs() const ; + // unary negate + const Number operator-() ; + // unary increment + Number& operator++() ; + const Number operator++(int) ; + // unary decrement + Number& operator--() ; + const Number operator--(int) ; + // assigment operator + Number& operator=(const Number &a); + // add and assign + Number& operator+=(const Number &a) ; + // subtract and assign + Number& operator-=(const Number &a) ; + // Mulitply an assign + Number& operator*=(const Number &a) ; + // divide and assign + Number& operator/=(const Number &a) ; + // Modulo and assign + Number& operator%=(const Number &a) ; + // casting operators + operator long() const; + operator int() const; + operator short() const; + operator char() const; + operator signed char() const; + operator unsigned long() const; + operator unsigned int() const; + operator unsigned short() const; + operator unsigned char() const; + operator long double() const; + operator double() const; + operator float() const; + // Decimal shift + const Number shift(int val) const ; + // Integer Power + const Number intPower(int val) const ; + const Number ceil() const ; + const Number floor() const ; + const Number squareroot() const ; + int sign() const ; + // conversion routines + // Format Number and return as a OCCI_STD_NAMESPACE::string + OCCI_STD_NAMESPACE::string toText(const Environment *envp, + const OCCI_STD_NAMESPACE::string &fmt, + const OCCI_STD_NAMESPACE::string &nlsParam="") const + ; + UString toText(const Environment *envp, + const UString &fmt,const UString &nlsParam) const + ; + // Create an Number from formatted text + void fromText(const Environment *envp, + const OCCI_STD_NAMESPACE::string &number, + const OCCI_STD_NAMESPACE::string &fmt, + const OCCI_STD_NAMESPACE::string &nlsParam = "") + ; + void fromText(const Environment *envp, + const UString &number, + const UString &fmt, const UString &nlsParam); + void fromBytes(const Bytes &s) ; + Bytes toBytes() const; + // truncate digits + const Number trunc(int decplace) const ; + // round to the decplace place. + const Number round(int decplace) const ; + // returns an Number with digits decimal digits + const Number prec(int digits) const ; + const Number sin() const ; + const Number cos() const ; + const Number tan() const ; + const Number hypSin() const ; + const Number hypCos() const ; + const Number hypTan() const ; + const Number arcSin() const ; + const Number arcCos() const ; + const Number arcTan() const ; + const Number arcTan2(const Number &val) const; + const Number power(const Number &val) const; + const Number exp() const ; + const Number ln() const ; + const Number log(const Number &val) const; + bool isNull() const; + void setNull(); + private: + /* Private constructor for constructing number from methods inside */ + Number(const OCINumber &result); + OCINumber getOCINumber() const; + + OCINumber data; + /* a flag to indicate if the Number is null */ + bool numberIsNull; + void *numberExt; + + // a >= b + friend bool operator>=(const Number &a, const Number &b); + // a < = b + friend bool operator<=(const Number &a, const Number &b); + // a > b + friend bool operator>(const Number &a, const Number &b); + // a < b + friend bool operator<(const Number &a, const Number &b); + + friend class IntervalDS; + friend class IntervalYM; + friend const IntervalYM operator*(const IntervalYM &a, + const Number& factor) ; + friend const IntervalDS operator*(const IntervalDS &a, + const Number& factor) ; + friend const IntervalYM operator/(const IntervalYM &a, + const Number &factor) ; + friend const IntervalDS operator/(const IntervalDS &a, + const Number &factor) ; + friend class ResultSetImpl; + friend class StatementImpl; + friend class AnyDataImpl; + friend void getVector(const AnyData &any, + OCCI_STD_NAMESPACE::vector &vect); + friend void setVector(AnyData &any, + const OCCI_STD_NAMESPACE::vector &vect) ; + friend Number MetaData::getNumber(MetaData::AttrId attrid) const ; + friend void getVector(Statement *stmt, unsigned int paramIndex, + OCCI_STD_NAMESPACE::vector &vect) ; + friend void do_setVectorOfNumber(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, void *schemaName, + unsigned int schemaNameLen, + void *typeName, unsigned int typeNameLen); + friend void getVector(ResultSet *rs, unsigned int colIndex, + OCCI_STD_NAMESPACE::vector &vect); + +}; + +class Date +{ + public: + + // Constructors + Date(); + Date(const Date &a); + Date(const Environment *envp,int year = 1,unsigned int month = 1, + unsigned int day = 1,unsigned int hour = 0, + unsigned int minute = 0, unsigned int seconds = 0); + ~Date(); + // Methods + + void setDate(int year = 1,unsigned int month = 1,unsigned int day = 1, + unsigned int hour = 0,unsigned int minute = 0, + unsigned int seconds = 0); + void getDate(int &year,unsigned int &month,unsigned int &day, + unsigned int &hour ,unsigned int &min ,unsigned int &sec) const; + Bytes toBytes() const ; + void fromBytes(const Bytes &byteStream, + const Environment *envp = NULL); + OCCI_STD_NAMESPACE::string toText( + const OCCI_STD_NAMESPACE::string &fmt = "", + const OCCI_STD_NAMESPACE::string &nlsParam = "") const; + UString toText( + const UString &fmt , + const UString &nlsParam ) const; + void fromText(const OCCI_STD_NAMESPACE::string &datestr, + const OCCI_STD_NAMESPACE::string &fmt = "", + const OCCI_STD_NAMESPACE::string &nlsParam = "", + const Environment *envp = NULL); + void fromText(const UString &datestr, + const UString &fmt , const UString &nlsParam , + const Environment *envp = NULL); + Date toZone(const OCCI_STD_NAMESPACE::string &zone1, + const OCCI_STD_NAMESPACE::string &zone2) const; + Date& operator=(const Date &d); + Date addMonths(int i) const; + Date addDays(int i) const ; + Date lastDay() const ; + IntervalDS daysBetween(const Date &d) const; + Date nextDay(const OCCI_STD_NAMESPACE::string &dow) const; + Date nextDay(const UString &dow) const; + bool isNull() const; + void setNull(); + static Date getSystemDate(const Environment *envp) ; + + private: + OCIDate date; + const EnvironmentImpl *envp; + bool dateIsNull; + void *dateExt; + + /* private constructor */ + Date(const Environment *env,OCIDate dateval); + OCIDate getOCIDate() const; + void constructHourAndMinute(sb4 &seconds, sb4 &hours, sb4 &minutes) const; + friend bool operator==(const Date &a,const Date &b); + friend bool operator>(const Date &a,const Date &b); + friend bool operator<(const Date &a,const Date &b); + friend bool operator!=(const Date &a,const Date &b); + friend bool operator>=(const Date &a,const Date &b); + friend bool operator<=(const Date &a,const Date &b); + friend class ResultSetImpl; + friend class StatementImpl; + friend class AnyDataImpl; + friend class aq::MessageImpl; + friend void getVector(const AnyData &any, + OCCI_STD_NAMESPACE::vector &vect) ; + friend void setVector(AnyData &any, + const OCCI_STD_NAMESPACE::vector &vect); + friend void getVector(Statement *stmt, unsigned int paramIndex, + OCCI_STD_NAMESPACE::vector &vect) ; + friend void do_setVectorOfDate(Statement *stmt, unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, void *schemaName, + unsigned int schemaNameLen,void *typeName, unsigned int typeNameLen) ; + friend void getVector(ResultSet *rs, unsigned int colIndex, + OCCI_STD_NAMESPACE::vector &vect) ; + +}; //class Date + +class Timestamp +{ + public: + Timestamp() ; + + Timestamp( const Environment *env, int year=1, + unsigned int month=1, unsigned int day=1, unsigned int hour=0, + unsigned int min=0 ,unsigned int sec=0, unsigned int fs=0, + int tzhour=0, int tzmin=0) ; + Timestamp( const Environment *env, int year, + unsigned int month, unsigned int day, unsigned int hour, + unsigned int min ,unsigned int sec, unsigned int fs, + const OCCI_STD_NAMESPACE::string &timezone); + Timestamp( const Environment *env, int year, + unsigned int month, unsigned int day, unsigned int hour, + unsigned int min ,unsigned int sec, unsigned int fs, + const UString &timezone); + Timestamp( const Timestamp &src) ; + ~Timestamp(); + + void getTimeZoneOffset( int &hour, int &minute) const ; + void getTime( unsigned int &hour, unsigned int &minute, + unsigned int &second, unsigned int &fs) const ; + void getDate( int &year, unsigned int &month, unsigned int &day )const ; + OCCI_STD_NAMESPACE::string toText(const OCCI_STD_NAMESPACE::string &fmt, + unsigned int fsprec, + const OCCI_STD_NAMESPACE::string &nlsParam ="") const ; + UString toText(const UString &fmt, + unsigned int fsprec, const UString &nlsParam ) const ; + void setTimeZoneOffset( int hour, int minute) ; + void setTime( unsigned int hour, unsigned int minute, + unsigned int second, unsigned int fs) ; + void setDate( int year, unsigned int month, unsigned int day ) ; + void setNull() ; + void fromText( const OCCI_STD_NAMESPACE::string ×tmpStr, + const OCCI_STD_NAMESPACE::string &fmt , + const OCCI_STD_NAMESPACE::string &nlsParam= "", + const Environment *env =NULL); + void fromText( const UString ×tmpStr, + const UString &fmt , const UString &nlsParam, + const Environment *env =NULL); + bool isNull() const; + Timestamp & operator =( const Timestamp &src) ; + const IntervalYM subYM(const Timestamp& val) const ; + const IntervalDS subDS(const Timestamp& val) const ; + const Timestamp intervalAdd(const IntervalDS& val) const ; + const Timestamp intervalSub(const IntervalDS& val) const ; + const Timestamp intervalAdd(const IntervalYM& val) const ; + const Timestamp intervalSub(const IntervalYM& val) const ; + + friend bool operator==(const Timestamp &a,const Timestamp &b); + friend bool operator>(const Timestamp &a,const Timestamp &b); + friend bool operator<(const Timestamp &a,const Timestamp &b); + friend bool operator !=(const Timestamp &a,const Timestamp &b); + friend bool operator >=(const Timestamp &a,const Timestamp &b); + friend bool operator <=(const Timestamp &a,const Timestamp &b); + + friend class ResultSetImpl; + friend class StatementImpl; + friend class AnyDataImpl; + + private: + OCIDateTime *ocidatetime; + OCIEnv *ocienv; + void *timestampExt; + + OCIDateTime *getOCIDateTime() const; + Timestamp( OCIEnv *env, OCIDateTime *dt, bool toCopy = true) ; + void allocateDataMembers( OCIEnv *env) ; + void do_TimestampConstruct( const Environment *env, int year, + unsigned int month, unsigned int day, unsigned int hour, unsigned int min, + unsigned int sec, unsigned int fs, void *tzinter); + + friend void getVector(const AnyData &any, + OCCI_STD_NAMESPACE::vector &vect); + friend void setVector(AnyData &any, + const OCCI_STD_NAMESPACE::vector &vect) ; + friend Timestamp MetaData::getTimestamp( + MetaData::AttrId attrid) const ; + friend void getVector(ResultSet *rs, unsigned int, + OCCI_STD_NAMESPACE::vector &vect) ; + friend void getVector(Statement *rs, unsigned int, + OCCI_STD_NAMESPACE::vector &vect) ; + friend void do_setVectorOfTimestamp(Statement *stmt, + unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + void *schemaName, unsigned int schemaNameLen, + void *typeName, unsigned int typeNameLen) ; +}; // class Timestamp + +class IntervalDS +{ + + public: + IntervalDS() ; + IntervalDS( const Environment *env,int day=0, + int hour=0, int minute=0, int second=0, + int fs=0) ; + IntervalDS( const IntervalDS &src) ; + + ~IntervalDS(); + + int getDay () const ; + int getHour () const ; + int getMinute () const ; + int getSecond() const ; + int getFracSec () const ; + void set( int day, int hour, int minute, int second, int fracsec) ; + void setNull() ; + void fromText( const OCCI_STD_NAMESPACE::string &inpstr, + const OCCI_STD_NAMESPACE::string &nlsParam ="", + const Environment *env=NULL) ; + OCCI_STD_NAMESPACE::string toText( unsigned int lfprec, unsigned int fsprec, + const OCCI_STD_NAMESPACE::string &nlsParam="") const ; + bool isNull() const; + IntervalDS& operator =( const IntervalDS &src) ; + IntervalDS& operator +=( const IntervalDS &a); + IntervalDS& operator -=( const IntervalDS &a); + IntervalDS& operator *=( const Number &factor); + IntervalDS& operator /=( const Number &factor); + + friend bool operator>(const IntervalDS &a, + const IntervalDS &b) ; + friend bool operator<(const IntervalDS &a, + const IntervalDS &b) ; + friend bool operator >=( const IntervalDS &a, + const IntervalDS &b); + friend bool operator <=( const IntervalDS &a, + const IntervalDS &b); + + //UTF16 support + void fromUText( const UString &inpstr, const Environment *env=NULL ); + UString toUText( unsigned int lfprec, unsigned int fsprec) const; + + private: + OCIInterval *ociinter; + OCIEnv *ocienv; + void *intervalDSExt; + + IntervalDS( OCIEnv *env, OCIInterval *inter, bool toCopy = true) ; + OCIInterval * getOCIInterval() const; + + void allocateDataMembers( OCIEnv *env) ; + friend const IntervalDS Timestamp::subDS( + const Timestamp& val) const ; + friend const Timestamp Timestamp::intervalAdd( + const IntervalDS& val) const ; + friend const Timestamp Timestamp::intervalSub( + const IntervalDS& val) const ; + friend class Date; + friend void getVector(ResultSet *rs, unsigned int, + OCCI_STD_NAMESPACE::vector &vect) ; + friend void getVector(Statement *rs, unsigned int, + OCCI_STD_NAMESPACE::vector &vect) ; + friend void do_setVectorOfIntervalDS(Statement *stmt, + unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + void *schemaName, unsigned int schemaNameLen, + void *typeName, unsigned int typeNameLen) ; + friend class StatementImpl; + friend class ResultSetImpl; + friend class AnyDataImpl; + friend void getVector(const AnyData &any, + OCCI_STD_NAMESPACE::vector &vect); + friend void setVector(AnyData &any, + const OCCI_STD_NAMESPACE::vector &vect) ; + + +}; //class IntervalDS + +class IntervalYM +{ + + public: + IntervalYM() ; + IntervalYM( const Environment *env,int year=0, int month=0) ; + IntervalYM( const IntervalYM &src) ; + ~IntervalYM(); + + int getYear() const ; + int getMonth() const ; + + void set( int year, int month) ; + void setNull() ; + void fromText( const OCCI_STD_NAMESPACE::string &inpstr, + const OCCI_STD_NAMESPACE::string &nlsParam="", + const Environment *env=NULL) ; + OCCI_STD_NAMESPACE::string toText( unsigned int lfprec, + const OCCI_STD_NAMESPACE::string &nlsParam="") const; + bool isNull() const; + IntervalYM & operator =( const IntervalYM &src) ; + IntervalYM& operator +=( const IntervalYM &a); + IntervalYM& operator -=( const IntervalYM &a); + IntervalYM& operator *=( const Number &factor); + IntervalYM& operator /=( const Number &factor); + + friend bool operator>(const IntervalYM &a, const IntervalYM &b) ; + friend bool operator<( const IntervalYM &a, const IntervalYM &b) ; + friend bool operator >=(const IntervalYM &a, const IntervalYM &b); + friend bool operator <=(const IntervalYM &a, const IntervalYM &b); + + //UTF16 support + void fromUText( const UString &inpstr, const Environment *env=NULL ); + UString toUText( unsigned int lfprec ) const; + + private: + OCIInterval *ociinter; + OCIEnv *ocienv; + void *intervalYMExt; + + IntervalYM( OCIEnv *env, OCIInterval *inter, bool toCopy = true) ; + OCIInterval *getOCIInterval() const; + void allocateDataMembers( OCIEnv *env) ; + friend const IntervalYM Timestamp :: subYM( + const Timestamp& val) const ; + friend const Timestamp Timestamp::intervalAdd( + const IntervalYM &val) const ; + friend const Timestamp Timestamp::intervalSub( + const IntervalYM &val) const ; + + friend void getVector(ResultSet *rs, unsigned int, + OCCI_STD_NAMESPACE::vector &vect) ; + friend void getVector(Statement *rs, unsigned int, + OCCI_STD_NAMESPACE::vector &vect) ; + friend void do_setVectorOfIntervalYM(Statement *stmt, + unsigned int paramIndex, + const OCCI_STD_NAMESPACE::vector &vect, + void *schemaName, unsigned int schemaNameLen, + void *typeName, unsigned int typeNameLen) ; + + friend class StatementImpl; + friend class ResultSetImpl; + friend class AnyDataImpl; + friend void getVector(const AnyData &any, + OCCI_STD_NAMESPACE::vector &vect); + friend void setVector(AnyData &any, + const OCCI_STD_NAMESPACE::vector &vect) ; + +}; //class IntervalYM + + +Number operator+(const Number &a, const Number &b) ; +Number operator/(const Number ÷nd, const Number &divisor) ; +Number operator*(const Number &a, const Number &b) ; +Number operator%(const Number &a, const Number &b) ; +Number operator-(const Number &subtrahend, const Number &subtractor) ; +bool operator==(const Number &a, const Number &b); +bool operator!=(const Number &a, const Number &b); + +const IntervalYM operator+(const IntervalYM &a, const IntervalYM &b) ; +const IntervalYM operator-(const IntervalYM &a, const IntervalYM &b) ; +const IntervalYM operator*(const IntervalYM &a, const Number& factor); +const IntervalYM operator/(const IntervalYM &a, const Number &factor); +bool operator==(const IntervalYM &a, const IntervalYM &b) ; +bool operator!=(const IntervalYM &a, const IntervalYM &b) ; + +const IntervalDS operator+(const IntervalDS &a, const IntervalDS &b) ; +const IntervalDS operator-(const IntervalDS &a, const IntervalDS &b) ; +const IntervalDS operator*(const IntervalDS &a, const Number& factor); +const IntervalDS operator/(const IntervalDS &a, const Number &factor); +bool operator==(const IntervalDS &a, const IntervalDS &b) ; +bool operator!=(const IntervalDS &a, const IntervalDS &b) ; + + +typedef struct BFloat +{ + float value; + bool isNull; + + BFloat() + { + isNull = false; + value = 0.; + } +} BFloat; + +typedef struct BDouble +{ + double value; + bool isNull; + + BDouble() + { + isNull = false; + value = 0.; + } +} BDouble; + +/*--------------------------------------------------------------------------- + EXPORT FUNCTIONS + ---------------------------------------------------------------------------*/ + + +/*--------------------------------------------------------------------------- + INTERNAL FUNCTIONS + ---------------------------------------------------------------------------*/ + + +#ifdef ORAXB8_DEFINED +/* + NAME + Lob Region class + + DESCRIPTION + Contains the implementation of the Lob Region template Class. + This class is the underlying implementation for the BlobRegion and + ClobRegion classes. + + RELATED DOCUMENTS + Functional/Design Specifications: + 18209 - Next Generation LOBs: API + 18206 - Next Generation LOBs: Comb. Storage, Compressio & Encryption + + EXPORT FUNCTION(S) + LobRegion() - constructors + ~LobRegion() - destructor + getPrimary() - Get the Primary Lob object + getPrimaryOffset() - Get the offset of this region in the Primary Lob. + getOffset() - Get the offset of this region in this lob. + getLength() - Get the length of this region + getMimeType() - Get the mime type of this region + + PUBLIC IMPLEMENTATION FUNCTION(S) + + INTERNAL FUNCTION(S) + none + + EXAMPLES + + NOTES +*/ + +/*------------------------------ LobRegion ------------------*/ +/* + NAME + LobRegion - constructor for the class + + PARAMETERS + none + + DESCRIPTION + default constructor + + RETURNS + Nothing + + NOTES +*/ +template +LobRegion::LobRegion() +{ + _primary = (lobType *)0; + _primaryOffset = 0; + _offset = 0; + _length = 0; +} + +/*------------------------------ ~LobRegion ------------------*/ +/* + NAME + ~LobRegion - destructor for the class + + PARAMETERS + none + + DESCRIPTION + default constructor + + RETURNS + Nothing + + NOTES +*/ +template +LobRegion::~LobRegion() +{ + if (_primary != (lobType *)0) + { + delete _primary; + } +} + +template +lobType *LobRegion::getPrimary() +{ + return _primary; +} + +template +oraub8 LobRegion::getPrimaryOffset() +{ + return _primaryOffset; +} + +template +oraub8 LobRegion::getOffset() +{ + return _offset; +} + +template +oraub8 LobRegion::getLength() +{ + return _length; +} + +template +OCCI_STD_NAMESPACE::string LobRegion::getMimeType() +{ + return _mimeType; +} + +template +void LobRegion::setPrimary(const ConnectionImpl *connp, + OCILobLocator *locator) +{ + if (locator != (OCILobLocator *)0) + { + _primary = new lobType(connp, locator, true); + } +} + +#endif /* ORAXB8_DEFINED */ + +} /* end of namespace occi */ +} /* end of namespace oracle */ +#endif /* OCCIDATA_ORACLE */ + +#endif /* _olint */ diff --git a/OCI/include/occiObjects.h b/OCI/include/occiObjects.h new file mode 100644 index 0000000..1b301ad --- /dev/null +++ b/OCI/include/occiObjects.h @@ -0,0 +1,910 @@ +/* Copyright (c) 2000, 2007, Oracle. All rights reserved. */ + +/* + NAME + occiObjects.h - header file for OCCI object classes + + DESCRIPTION + Class definitions for Ref, RefAny, AnyData + + RELATED DOCUMENTS + + + EXPORT FUNCTION(S) + + + INTERNAL FUNCTION(S) + + + EXAMPLES + + NOTES + + + +*/ + +#ifndef _olint /* disable olint check */ + +#ifndef OCCIOBJECTS_ORACLE +# define OCCIOBJECTS_ORACLE + +#ifndef OCCICOMMON_ORACLE +#include +#endif + +namespace oracle { +namespace occi { +struct AnyDataCtx { + ConnectionImpl *occiSession; + OCIAnyData *anyData; + void *objHeader; + ub4 errNum; +}; +typedef struct AnyDataCtx AnyDataCtx; + +class PObject +{ + public: + enum LockOption {OCCI_LOCK_WAIT, OCCI_LOCK_NOWAIT}; + enum UnpinOption {OCCI_PINCOUNT_DECR, OCCI_PINCOUNT_RESET}; + static void destroy(void *); + static void refresh(void *); + PObject(); + PObject(const void *ctx); + PObject(const PObject& obj); + virtual ~PObject(); + PObject& operator=(const PObject& obj); + void *operator new(size_t size); + void *operator new(size_t size, const Connection *x, + const OCCI_STD_NAMESPACE::string& tablename, + const char *typeName); + void *operator new(size_t size, const Connection *sess, + const OCCI_STD_NAMESPACE::string& tablename, + const OCCI_STD_NAMESPACE::string& typName , + const OCCI_STD_NAMESPACE::string& schTabName="", + const OCCI_STD_NAMESPACE::string& schTypName = ""); + void *operator new(size_t size, const Connection *sess, + const UString& tablename, const UString &typName, + const UString& schTabName, const UString& schTypName); + void *operator new(size_t size, void *adctx); + void operator delete(void *obj, size_t size); + RefAny getRef() const; + bool isLocked() const; + void unpin(UnpinOption mode=OCCI_PINCOUNT_DECR); + void pin(); + void lock(PObject::LockOption lock_option); + void unmark(); + void flush(); + void markDelete(); + void markModified(); + bool isNull() const; + void setNull(); + const Connection *getConnection() const; + virtual OCCI_STD_NAMESPACE::string getSQLTypeName() const = 0; + virtual void getSQLTypeName(Environment *env, void **schName, + unsigned int &schNameLen, void **typeName, + unsigned int &typeNameLen) const = 0; + void getSQLTypeName(Environment *env, void *(*rSQL)(void *), + void **schname, unsigned int &schnamelen, + void **typname, unsigned int &typnamelen) const; + virtual void writeSQL(AnyData& stream) = 0; + virtual void readSQL(AnyData& stream) = 0; + private: + static void initialise( void * obj, const Connection * sess, + void *schTabName, unsigned int schTabLen, + void *tableName, unsigned int tabLen, + void *schTypName, unsigned int schTypLen, + void *typeName, unsigned int typLen); + + ConnectionImpl *occiSession_; + void *objHeader_; + ub2 customNewed_; + enum {CUSTOM_NEWED = 0x5cde}; + ub2 flags_; + enum {NULL_INFO = 0x0001, GARBAGE_COLLECTED = 0x0002, + REFRESH_OBJECT = 0x0004, + CACHED_OBJECT = 0xBAF8}; + //check PObject implementation for CACHED_OBJECT flag + // for future use + void *pobjectExt; + friend class RefImpl; +}; + +class AnyData +{ + public: + ~AnyData(); + AnyData(void *any) ; + AnyData(const Connection *sessp); + AnyData(const Connection *sessp, OCIAnyData *any, bool freeImg = true) ; + + AnyData(const AnyData &src); + AnyData& operator = (const AnyData &src); + + OCIAnyData* getOCIAnyData() const; + const Connection* getConnection() const; + + + bool isNull() const ; + void setNull() ; + OCCI_STD_NAMESPACE::string getString() const ; + UString getUString() const ; + Blob getBlob() const ; + Clob getClob() const ; + Bfile getBfile() const ; + BFloat getBFloat() const ; + BDouble getBDouble() const ; + Number getNumber() const ; + Bytes getBytes() const ; + Date getDate() const ; + Timestamp getTimestamp() const ; + IntervalYM getIntervalYM() const ; + IntervalDS getIntervalDS() const ; + PObject *getObject(void *(*rSQL)(void *)) const ; + RefAny getRef() const ; + + void setString(const OCCI_STD_NAMESPACE::string &str) ; + void setUString(const UString &str) ; + void setBlob(const Blob &blob) ; + void setClob(const Clob &clob) ; + void setBfile(const Bfile &bfile) ; + void setBFloat(const BFloat &n) ; + void setBDouble(const BDouble &n) ; + void setNumber(const Number &n) ; + void setBytes(const Bytes &bytes) ; + void setDate(const Date &date) ; + void setTimestamp(const Timestamp ×tamp) ; + void setIntervalYM(const IntervalYM &intervalym) ; + void setIntervalDS(const IntervalDS &intervalds) ; + void setObject(const PObject *objptr) ; + void setRef(const RefAny &ref) ; + + void setFromString(const OCCI_STD_NAMESPACE::string &str) ; + void setFromBfile(const Bfile &bfile) ; + void setFromBFloat(const BFloat &n) ; + void setFromBDouble(const BDouble &n) ; + void setFromNumber(const Number &n) ; + void setFromBytes(const Bytes &bytes) ; + void setFromDate(const Date &date) ; + void setFromTimestamp(const Timestamp ×tamp) ; + void setFromIntervalYM(const IntervalYM &intervalym) ; + void setFromIntervalDS(const IntervalDS &intervalds) ; + void setFromObject(const PObject *objptr) ; + void setFromRef(const RefAny &ref, + const OCCI_STD_NAMESPACE::string &typname, + const OCCI_STD_NAMESPACE::string &schname) ; + + OCCI_STD_NAMESPACE::string getAsString() const ; + Bfile getAsBfile() const ; + BFloat getAsBFloat() const ; + BDouble getAsBDouble() const ; + Number getAsNumber() const ; + Bytes getAsBytes() const ; + Date getAsDate() const ; + Timestamp getAsTimestamp() const ; + IntervalYM getAsIntervalYM() const ; + IntervalDS getAsIntervalDS() const ; + PObject *getAsObject() const ; + RefAny getAsRef() const ; + + TypeCode getType() const; + + private: + + + // private data members + Ptr anyDataImplPtr; + + +}; + +template +class Ref +{ + public: + + Ref(); + Ref(const T *obj) ; + Ref(const RefAny &refAny) ; + Ref(const Ref &src) ; + Ref(const Connection *sessp, OCIRef *tref, bool copy=TRUE) + ; + ~Ref(); + Ref& operator=(const Ref &src) + ; + Ref& operator=(const T *obj) ; + Ref& operator=(const RefAny &src); + T * operator->() ; + T * ptr() ; + T & operator *() ; + const T * operator->() const; + const T * ptr() const; + const T & operator *() const ; + void markDelete() ; + void unmarkDelete() ; + void setNull(); + bool isNull() const; + void clear() ; + bool isClear() const; + void setPrefetch(const OCCI_STD_NAMESPACE::string &typeName, + unsigned int depth); + void setPrefetch(const OCCI_STD_NAMESPACE::string &schName, + const OCCI_STD_NAMESPACE::string &typeName, + unsigned int depth); + void setPrefetch(const UString &schName, + const UString &typeName, + unsigned int depth); + void setPrefetch(unsigned int depth) ; + void setLock(LockOptions ); + operator RefAny() const; + OCIRef *getRef() const; + const Connection *getConnection() const; + bool operator == (const Ref &ref) const; + bool operator != (const Ref &ref) const; + bool operator == (const RefAny &refAnyR) const ; + bool operator != (const RefAny &refAnyR) const ; + OCIComplexObject *getCor() const; + void setPinnedObject(PObject *objPtr); + private: + + RefImpl *rimplPtr; +}; + + +class RefImpl +{ + public: + + RefImpl(); + RefImpl(PObject *obj) ; + RefImpl(const RefAny &refAny) ; + RefImpl(const RefImpl &src) ; + RefImpl(const Connection *sessp, OCIRef *tref, + bool copy=TRUE) ; + ~RefImpl(); + bool isNull() const ; + void setNull() ; + void markDelete() ; + void unmarkDelete() ; + void clear() ; + bool isClear() const ; + void setPrefetch(const OCCI_STD_NAMESPACE::string &typeName, + unsigned int depth) ; + void setPrefetch(const OCCI_STD_NAMESPACE::string &schName, + const OCCI_STD_NAMESPACE::string &typeName, + unsigned int depth); + void setPrefetch(const UString &schName, + const UString &typeName, + unsigned int depth); + void setPrefetch(unsigned int depth) ; + void setLock(LockOptions lckOption) ; + PObject *pin() ; + void unpin(PObject *obj) ; + void setRefFromObjPtr(const PObject *obj) ; + OCIRef* getRef() const; + void setRefImpl(RefImpl *rptr); + const Connection * getConnection() const; + bool operator == (const RefImpl &refI) const ; + bool operator == (const RefAny &refAnyR) const ; + void assignObj(PObject *newObjPtr) ; + void assignRefAny(const RefAny &src) ; + // added following methods + bool isEqual(PObject *obj); + void operator = ( const RefImpl &src); + OCIComplexObject *getCor() const; + void setPinnedObject( PObject *objPtr); + private: + + OCIRef *ref; + const ConnectionImpl *sessp; + OCIComplexObject *corhp; + OCCI_STD_NAMESPACE::list descriptorList; + LockOptions lockOption; + // added data member for object header + void *objHeader; + //common implementation function for setPrefetch + void do_setPrefetch(void *schName, unsigned int schNameLen, + void *typeName, unsigned int typeNameLen, + unsigned int depth); +}; + + +class RefAny +{ + public: + + RefAny(); + RefAny (const Connection *sessptr, const OCIRef *ref); + RefAny (const Connection *sessptr, const OCIRef *ref, bool isowner); + ~RefAny() ; + RefAny(const RefAny& src) ; + RefAny& operator=(const RefAny& src) ; + void markDelete() ; + void unmarkDelete() ; + void clear() ; + bool isNull() const; + OCIRef * getRef() const; + const Connection * getConnection() const; + bool operator == (const RefAny &refAnyR) const; + bool operator != (const RefAny &refAnyR) const; + bool isOwner() const; + + private: + + OCIRef *ref; + const ConnectionImpl *sessp; + // for future use + void *refanyExt; + bool owner; + + friend RefAny MetaData::getRef(MetaData::AttrId) const; + friend RefAny PObject::getRef() const; + friend class AnyDataImpl; + friend class ResultSetImpl; + friend class StatementImpl; + friend void getVector(const ResultSet *rs, + unsigned int colIndex, + OCCI_STD_NAMESPACE::vector &vect) ; + friend void getVector(const Statement *stmt, + unsigned int colIndex, + OCCI_STD_NAMESPACE::vector &vect) ; +}; + +template +Ref::Ref() +{ + rimplPtr = new RefImpl(); +} + +template +Ref::Ref(const T *obj) +{ + rimplPtr = new RefImpl((PObject *)obj); +} + +template +Ref::Ref(const RefAny &refAny) + +{ + rimplPtr = new RefImpl(refAny); +} + +template +Ref::Ref(const Ref& src) + +{ + rimplPtr = new RefImpl(*(src.rimplPtr)); +} + +template +Ref::Ref(const Connection *sessp, OCIRef *tref, bool copy) + +{ + rimplPtr = new RefImpl(sessp, tref, copy); +} + +template +Ref::~Ref() +{ + delete rimplPtr; +} + + +template +Ref& Ref::operator=(const Ref &src) +{ + if (&src == this) + return *this; + *rimplPtr = *(src.rimplPtr); + return *this; +} + +template +Ref& Ref::operator=(const T *obj) +{ + if (rimplPtr->isEqual((PObject *)obj)) + return *this; + rimplPtr->assignObj((PObject *)obj); + return *this; +} + +template +Ref& Ref::operator=(const RefAny &src) +{ + rimplPtr->assignRefAny(src); + return *this; +} + +template +T* Ref::operator->() +{ + return ((T *)rimplPtr->pin()); +} + +template +T* Ref::ptr() +{ + return ((T *)rimplPtr->pin()); +} + +template +T& Ref::operator * () +{ + return ((T &)(*(rimplPtr->pin()))); +} + +template +const T* Ref::operator->() const +{ + return ((const T *)rimplPtr->pin()); +} + +template +const T* Ref::ptr() const +{ + return ((const T *)rimplPtr->pin()); +} + +template +const T& Ref::operator * () const +{ + return ((const T &)(*(rimplPtr->pin()))); +} + +template +void Ref::markDelete () +{ + rimplPtr->markDelete(); +} + +template +void Ref::unmarkDelete () +{ + rimplPtr->unmarkDelete(); +} + +template +void Ref::setNull() +{ + rimplPtr->setNull(); +} + +template +bool Ref::isNull() const +{ + return rimplPtr->isNull(); +} + +template +void Ref::clear () +{ + rimplPtr->clear(); +} + +template +bool Ref::isClear() const +{ + return rimplPtr->isClear(); +} + +template +void Ref::setPrefetch (const OCCI_STD_NAMESPACE::string &typeName, +unsigned int depth) + +{ + rimplPtr->setPrefetch(typeName,depth); +} + +template +void Ref::setPrefetch (const OCCI_STD_NAMESPACE::string &schemaName, +const OCCI_STD_NAMESPACE::string &typeName, +unsigned int depth) + +{ + rimplPtr->setPrefetch(schemaName,typeName,depth); +} + +template +void Ref::setPrefetch (const UString &schemaName, +const UString &typeName, +unsigned int depth) + +{ + rimplPtr->setPrefetch(schemaName,typeName,depth); +} + +template +void Ref::setPrefetch (unsigned int depth) + +{ + rimplPtr->setPrefetch(depth); +} + +template +void Ref::setLock (LockOptions lckOption) +{ + rimplPtr->setLock(lckOption); +} + +template +OCIRef* Ref::getRef() const +{ + return (rimplPtr->getRef()); +} + +template +const Connection* Ref::getConnection () const +{ + return (rimplPtr->getConnection()); +} + +template +Ref::operator RefAny () const +{ + if (isNull()) + return RefAny(); + return (RefAny(rimplPtr->getConnection(), rimplPtr->getRef())); +} + +template +bool Ref::operator ==(const Ref &ref) const + +{ + return ( (*rimplPtr) == (*(ref.rimplPtr)) ); +} + +template +bool Ref::operator !=(const Ref &ref) const + +{ + return ( !((*rimplPtr) == (*(ref.rimplPtr))) ); +} + +template +bool Ref::operator == (const RefAny & refAnyR) const + +{ + return ( (*rimplPtr) == refAnyR ); +} + +template +bool Ref::operator != (const RefAny & refAnyR) const + +{ + return ( !((*rimplPtr) == refAnyR )); +} + +template +OCIComplexObject * Ref::getCor() const +{ + return (rimplPtr->getCor()); +} + +template < class T> +void Ref::setPinnedObject( PObject *objPtr) +{ + rimplPtr->setPinnedObject(objPtr); +} + +/*--------------------------------------------------------------------------- + PROTOTYPES USED BY FUNCTION TEMPLATES + ---------------------------------------------------------------------------*/ + void getVectorOfOCIRefs( const AnyData &any, + OCCI_STD_NAMESPACE::vector &vect); + void getVectorOfPObjects( const AnyData &any, + OCCI_STD_NAMESPACE::vector< PObject* > &vect, + void *(*rSQL)(void *)) ; + void setVectorOfOCIRefs( AnyData &any, + const OCCI_STD_NAMESPACE::vector &vect, + const OCCI_STD_NAMESPACE::vector< OCIInd> &vec_ind) ; + void setVectorOfPObjects( AnyData &any, + const OCCI_STD_NAMESPACE::vector< PObject* > &vect) ; + +/*--------------------------------------------------------------------------- + EXPORT FUNCTIONS + ---------------------------------------------------------------------------*/ + +/*------------------- getVector for POBject----------------------------*/ +/* + NAME + getVector - overloaded function. Retrieves the attribute in the + current position as a vector of PObject + + PARAMETERS + any - AnyData + vect- reference to vector of PObject (OUT parameter). + + DESCRIPTION + Retrieves the attribute in the current position as a vector + of PObject + The attribute at the current position should be a collection + type (varray or nested table). The SQL type of the elements in + the collection should be compatible with PObject + + RETURNS + nothing + + NOTES + compatible SQL types : user defined types (SQLT_NTY) etc. +*/ + +#if defined(WIN32COMMON) || defined(__MVS__) +// and other platforms that do not support +// partial function template specialization + template + void getVector(const AnyData &any, OCCI_STD_NAMESPACE::vector &vect, + void *(*rSQL)(void *)) + { + OCCI_STD_NAMESPACE::vector< PObject *> vec_pobj; + getVectorOfPObjects( any, vec_pobj, rSQL); + + vect.clear(); + unsigned int size= vec_pobj.size(); + vect.reserve( size ); + for( unsigned int i=0; i< size; i++) + vect.push_back( (T)vec_pobj[i] ); + } +#else + template + void getVector(const AnyData &any, OCCI_STD_NAMESPACE::vector &vect, + void *(*rSQL)(void *)) + { + OCCI_STD_NAMESPACE::vector< PObject *> vec_pobj; + getVectorOfPObjects( any, vec_pobj, rSQL); + + vect.clear(); + unsigned int size= vec_pobj.size(); + vect.reserve( size ); + for( unsigned int i=0; i< size; i++) + vect.push_back( (T*)vec_pobj[i] ); + } +#endif /* end of #ifdef WIN32COMMON */ + + /*------------------- getVector for Ref----------------------------*/ +/* + NAME + getVector - overloaded function. Retrieves the attribute in the + current position as a vector of PObject + + PARAMETERS + any - AnyData + vect- reference to vector of PObject (OUT parameter). + + DESCRIPTION + Retrieves the attribute in the current position as a vector + of PObject + The attribute at the current position should be a collection + type (varray or nested table). The SQL type of the elements in + the collection should be compatible with PObject + + RETURNS + nothing + + NOTES + compatible SQL types : user defined types (SQLT_NTY) etc. +*/ +#if !defined(WIN32COMMON) && !defined(__MVS__) + template + void getVector(const AnyData &any,OCCI_STD_NAMESPACE::vector< Ref > &vect) + { + OCCI_STD_NAMESPACE::vector< void *> vec_ref; + getVectorOfOCIRefs( any, vec_ref); + + vect.clear(); + unsigned int size = vec_ref.size(); + vect.reserve( size ); + const Connection *sess = any.getConnection(); + + for (unsigned int i=0; i< size; i++) + { + if (vec_ref[i] == (OCIRef *)0) + vect.push_back(Ref()); // pushing a default-constructed Ref + else + vect.push_back(Ref(sess, (OCIRef *)vec_ref[i], FALSE)); + } + } +#endif /* end of #ifndef WIN32COMMON */ + +/*-----------------------setVector for PObject--------------------------*/ +/* + NAME + setVector - overloaded function. sets the attribute in the current + position of anydata with the vector elements. + + PARAMETERS + none. + + DESCRIPTION + sets the attribute in the current position in anydata with the + vector elements. + The attribute in the current position of anydata should be a + collection type. If the collection type is a varray, the input vector + size should be equal to the size of the varray. Also the SQL type of + the collection's elements should be compatible with PObject. + + RETURNS + nothing. + + NOTES + compatible SQL types : SQLT_NTY (user defined types). +*/ +#if defined(WIN32COMMON) || defined(__MVS__) +// and other platforms that do not support +// partial function template specialization + + template + void setVector(AnyData &any, const OCCI_STD_NAMESPACE::vector &vect) + { + OCCI_STD_NAMESPACE::vector< PObject *> vec_pobj; + unsigned int size= vect.size(); + vec_pobj.reserve( size ); + for( unsigned int i=0; i< size; i++) + vec_pobj.push_back( vect[i] ); + setVectorOfPObjects( any, vec_pobj); + + } + +#else + + template + void setVector(AnyData &any, const OCCI_STD_NAMESPACE::vector &vect) + { + OCCI_STD_NAMESPACE::vector< PObject *> vec_pobj; + unsigned int size= vect.size(); + vec_pobj.reserve( size ); + for( unsigned int i=0; i< size; i++) + vec_pobj.push_back( vect[i] ); + setVectorOfPObjects( any, vec_pobj); + + } +#endif /* end of #ifdef WIN32COMMON */ + +/*-----------------------setVector for Ref--------------------------*/ +/* + NAME + setVector - overloaded function. sets the attribute in the current + position of anydata with the vector elements. + + PARAMETERS + none. + + DESCRIPTION + sets the attribute in the current position in anydata with the + vector elements. + The attribute in the current position of anydata should be a + collection type. If the collection type is a varray, the input vector + size should be equal to the size of the varray. Also the SQL type of + the collection's elements should be compatible with PObject. + + RETURNS + nothing. + + NOTES + compatible SQL types : SQLT_NTY (user defined types). +*/ +#if !defined(WIN32COMMON) && !defined(__MVS__) + template + void setVector(AnyData &any, const OCCI_STD_NAMESPACE::vector< Ref > &vect) + { + OCCI_STD_NAMESPACE::vector< void *> vec_ref; + OCCI_STD_NAMESPACE::vector vec_ind; + + unsigned int size= vect.size(); + vec_ref.reserve( size ); + vec_ind.reserve( size ); + for( unsigned int i=0; i< size; i++) + { + vec_ref.push_back( vect[i].getRef() ); + vec_ind.push_back(vect[i].isNull() ? OCI_IND_NULL : OCI_IND_NOTNULL); + } + setVectorOfOCIRefs( any, vec_ref, vec_ind); + + } +#endif /* end of #ifndef WIN32COMMON */ + +// Platform independent get/setVectorOfRefs method added +// get(set)Vector of Ref and get(set)VectorOfRefs are identical +// in functionality. + + /*------------------- getVectorOfRefs for Ref----------------------------*/ +/* + NAME + getVectorOfRefs - overloaded function. Retrieves the attribute in the + current position as a vector of PObject + + PARAMETERS + any - AnyData + vect- reference to vector of PObject (OUT parameter). + + DESCRIPTION + Retrieves the attribute in the current position as a vector + of PObject + The attribute at the current position should be a collection + type (varray or nested table). The SQL type of the elements in + the collection should be compatible with PObject + + RETURNS + nothing + + NOTES + compatible SQL types : user defined types (SQLT_NTY) etc. +*/ + + template + void getVectorOfRefs(const AnyData &any, + OCCI_STD_NAMESPACE::vector< Ref > &vect) + { + OCCI_STD_NAMESPACE::vector< void *> vec_ref; + getVectorOfOCIRefs( any, vec_ref); + + vect.clear(); + unsigned int size = vec_ref.size(); + vect.reserve( size ); + const Connection *sess = any.getConnection(); + + for (unsigned int i=0; i< size; i++) + { + if (vec_ref[i] == (OCIRef *)0) + vect.push_back(Ref()); // pushing a default-constructed Ref + else + vect.push_back(Ref(sess, (OCIRef *)vec_ref[i], FALSE)); + } + } + +/*-----------------------setVectorOfRefs for Ref--------------------------*/ +/* + NAME + setVectorOfRefs - overloaded function. sets the attribute in the current + position of anydata with the vector elements. + + PARAMETERS + none. + + DESCRIPTION + sets the attribute in the current position in anydata with the + vector elements. + The attribute in the current position of anydata should be a + collection type. If the collection type is a varray, the input vector + size should be equal to the size of the varray. Also the SQL type of + the collection's elements should be compatible with PObject. + + RETURNS + nothing. + + NOTES + compatible SQL types : SQLT_NTY (user defined types). +*/ + + template + void setVectorOfRefs(AnyData &any, + const OCCI_STD_NAMESPACE::vector< Ref > &vect) + + { + OCCI_STD_NAMESPACE::vector< void *> vec_ref; + OCCI_STD_NAMESPACE::vector vec_ind; + + unsigned int size= vect.size(); + vec_ref.reserve( size ); + vec_ind.reserve( size ); + for( unsigned int i=0; i< size; i++) + { + vec_ref.push_back( vect[i].getRef() ); + vec_ind.push_back(vect[i].isNull() ? OCI_IND_NULL : OCI_IND_NOTNULL); + } + setVectorOfOCIRefs( any, vec_ref, vec_ind); + + } + + +/*--------------------------------------------------------------------------- + INTERNAL FUNCTIONS + ---------------------------------------------------------------------------*/ + + +} /* end of namespace occi */ +} /* end of namespace oracle */ +#endif /* OCCIOBJECTS_ORACLE */ + +#endif /* _olint */ diff --git a/OCI/include/oci.h b/OCI/include/oci.h new file mode 100644 index 0000000..7984141 --- /dev/null +++ b/OCI/include/oci.h @@ -0,0 +1,3045 @@ +/* Copyright (c) 1995, 2009, Oracle and/or its affiliates. +All rights reserved. */ + +/* + NAME + oci.h - V8 Oracle Call Interface public definitions + + DESCRIPTION + This file defines all the constants and structures required by a V8 + OCI programmer. + + RELATED DOCUMENTS + V8 OCI Functional Specification + Oracle Call Interface Programmer's Guide Vol 1 and 2 + + INSPECTION STATUS + Inspection date: + Inspection status: + Estimated increasing cost defects per page: + Rule sets: + + ACCEPTANCE REVIEW STATUS + Review date: + Review status: + Reviewers: + + PUBLIC FUNCTION(S) + None + + PRIVATE FUNCTION(S) + None + + EXAMPLES + + NOTES + + + MODIFIED (MM/DD/YY) + ssahu 04/15/09 - Add user handle as an attribute to session pool + handle + dalpern 03/17/09 - bug 7646876: applying_crossedition_trigger + kneel 11/21/08 - bump OCI version to 11.2 + thoang 09/24/08 - include ocixstream.h + asohi 08/25/08 - Bug 7320582 : AQ dequeue navigation flags fix + thoang 08/04/08 - Add XStream attributes + msowdaga 07/23/08 - Add flag OCI_SESSGET_SYSDBA + rphillip 03/21/08 - Add partition memory attribute + nikeda 04/15/08 - Support OCIP_ATTR_CONTYPE + mbastawa 12/24/07 - add server, envhp attributes + slynn 03/18/08 - + amullick 02/11/08 - add support for OCILobGet/SetContentType + tbhosle 01/07/08 - add OCI_ATTR_SUBSCR_IPADDR + nikeda 12/19/07 - Add OCI_SUBSCR_QOS_HAREG + rphillip 10/22/07 - Add OCI_ATTR_DIRPATH_NO_INDEX_ERRORS + debanerj 12/14/07 - Added OCI_ATTR_RESERVED_38 and OCI_ATTR_RESERVED_39 + umabhat 09/20/07 - bug6119750 added OCI_FNCODE_APPCTXSET & + OCI_FNCODE_APPCTXCLEARALL + debanerj 04/10/07 - XDS Attributes + msakayed 05/24/07 - Bug #5095734: add OCI_ATTR_DIRPATH_RESERVED_19 + schoi 03/02/07 - Get/SetOptions API change + ebatbout 03/30/07 - 5598333: Add OCI_ATTR_DIRPATH_RESERVED_18 + nikeda 03/21/07 - Add OCI_ATTR_RESERVED_37 + abande 03/06/07 - Remove attributes for global stmt cache and + metadata cache + rphillip 02/20/07 - Add OCI_ATTR_DIRPATH_RESERVED_17 + shan 11/16/06 - bug 5595911. + msakayed 12/04/06 - Bug #5660845: add OCI_DIRPATH_INPUT_OCI + gviswana 10/26/06 - Remove OCI_ATTR_CURRENT_EDITION + maramali 09/29/06 - bug 5568492, added OCI_NLS_LOCALE_A2_ISO_2_ORA + gviswana 09/29/06 - CURRENT_EDITION -> EDITION + aramappa 09/20/06 - Update major and minor version information + slynn 07/28/06 - Migrate to new 11g LOB terminiology + debanerj 07/20/06 - Add OCI_ATTR_LOBPREFETCH_LENGTH + mbastawa 06/25/06 - add OCI_ATTR_RESERVED_36 + hqian 05/22/06 - 11gR1 proj-18303: add OCI_SYSASM + dkogan 04/06/06 - disable charset validation by default + jhealy 05/15/06 - Add TimesTen OCI adapter. + slynn 06/20/06 - GetSharedRegions + rthammai 06/13/06 - add reserved attribute + msakayed 06/15/06 - Project 20586: interval partitioning support + debanerj 10/25/05 - LOB prefetch + slynn 05/25/06 - New NG Lob Functionality. + yujwang 05/16/06 - Add OCI_ATTR_RESERVED_33, OCI_ATTR_RESERVED_34 + abande 04/25/06 - 18297: Add attributes for global stmt cache and + metadata cache + ssvemuri 04/26/06 - Constants for Query Notification support + jgiloni 05/05/06 - Add OCI_ATCH_RESERVED_7 + mxyang 02/01/06 - Added OCI_ATTR_CURRENT_EDITION attribute + hqian 05/04/06 - new runtime capability attribute for asm volume + nikeda 06/06/06 - OCI_TT: Add new OCIP attributes + aramappa 04/17/06 - Added OCI_FNCODE_ARRAYDESCRIPTORALLOC and + OCI_FNCODE_ARRAYDESCRIPTORFREE + debanerj 05/04/06 - 18313: OCI Net Fusion + rupsingh 05/26/06 - + jacao 05/11/06 - + absaxena 04/17/06 - add notification grouping attributes + rpingte 02/02/06 - add OCI_ATCH_RESERVED_6 + rpingte 04/27/06 - Add OCI_ATTR_DRIVER_NAME + jawilson 02/14/06 - add OCI_FNCODE_AQENQSTREAM + kneel 04/03/06 - Adding support in kjhn for critical severity + rphillip 03/31/06 - Add OCI_ATTR_DIRPATH_RESERVED_14 + mxyang 02/01/06 - Added OCI_ATTR_APPLICATION_EDITION attribute + rphillip 01/30/06 - Add new DPAPI attrs + ebatbout 11/03/05 - Add direct path support for multiple subtypes + porangas 02/22/06 - 5055398: Define OCI_STMT_CALL + mbastawa 01/31/06 - add OCI_ATTR_RESERVED_26 + yohu 01/27/06 - align Execution Modes macros + sjanardh 01/25/06 - add OCI_EXEC_RESERVED_6 + sichandr 01/18/06 - add OCI_ATTR_XMLTYPE_BINARY_XML + yohu 12/22/05 - add OCI_TRANS_PROMOTE + srseshad 09/12/05 - stmtcache: callback + krajan 10/25/05 - Added ENABLE_BEQUEATH attach flag + mbastawa 09/16/05 - dbhygiene + porangas 07/20/04 - 1175350: adding attribute for ognfd + chliang 06/30/05 - add OCI_SUPPRESS_NLS_VALIDATION mode + aahluwal 03/15/05 - [Bug 4235014]:add ASM, Preconnect events + ssappara 08/12/04 - Bug3669429 add OCI_ATTR_DESC_SYNBAS + absaxena 03/24/05 - remove OCI_AQ_RESERVED_5 + mbastawa 03/01/05 - add OCI_EXEC_RESERVED_5 + msakayed 02/15/05 - Bug #3147299: Add OCI_ATTR_CURRENT_ERRCOL + aahluwal 01/11/05 - [Bug 3944589]: add OCI_AUTH_RESERVED_5 + nikeda 11/15/04 - Add OCIP_IIO + rvissapr 11/10/04 - bug 3843644 - isencrypted + hohung 11/22/04 - add OCI_BIND_RESERVED_3 + cchui 10/25/04 - add OCI_ATTR_PROXY_CLIENT + aahluwal 09/27/04 - add incarnation, reason, cardinality to event handle + msakayed 09/14/04 - column encryption support (project id 5578) + jacao 08/17/04 - Add OCI_ATTR_DB_CHARSET_ID + mhho 08/29/04 - resolve conflicting mode declaration + sgollapu 05/28/04 - Add OCI_AUTH_RESERVED_3 + mbastawa 08/05/04 - add OCI_ATTR_RESERVED_21 + ebatbout 07/27/04 - add OCI_ATTR_DIRPATH_RESERVED_9 and move all direct + path attributes into a separate area in this file. + clei 06/29/04 - add OCI_ATTR_ENCC_SIZE + weiwang 05/06/04 - add OCIAQListenOpts and OCIAQLisMsgProps + weiwang 04/30/04 - add OCI_AQ_RESERVED_5 + nbhatt 04/27/04 - add new attribute + ssvemuri 06/19/04 - change notification descriptors and attributes + ksurlake 06/01/04 - grabtrans 'ksurlake_txn_skmishra_clone' + ksurlake 05/13/04 - add subscriber handle attributes + mbastawa 06/01/04 - add 3 more OCI_FETCH_RESERVED modes + chliang 05/28/04 - add nchar literal replacement modes + nikeda 05/14/04 - [OLS on RAC] new authentication mode + debanerj 05/17/04 - 13064: add fncodes for LOB array Read and Write + nikeda 05/20/04 - [OCI Events] Add incarnation, cardinality,reason + nikeda 05/18/04 - [OCI Events] Add OCI_ATTR_SERVICENAME + nikeda 05/17/04 - Add event handle + nikeda 05/13/04 - [OCI Events] Rename HACBK->EVTCBK, HACTX->EVTCTX + nikeda 05/10/04 - [OCI Events] code review changes + nikeda 04/15/04 - [OCI Events] OCI_SESSRLS_DROPSESS_FORCE + nikeda 04/12/04 - [OCI Events] Add OCI_ATTR_USER_MEMORY + aahluwal 04/12/04 - add OCI_HNDLFR_RESERVED5 + vraja 04/28/04 - add options for redo sync on commit + aahluwal 05/29/04 - [OCI Events]: add support for svc, svc member events + nikeda 05/28/04 - grabtrans 'nikeda_oci_events_copy' + nikeda 05/18/04 - [OCI Events] Add OCI_ATTR_SERVICENAME + nikeda 05/17/04 - Add event handle + nikeda 05/13/04 - [OCI Events] Rename HACBK->EVTCBK, HACTX->EVTCTX + nikeda 05/10/04 - [OCI Events] code review changes + nikeda 04/15/04 - [OCI Events] OCI_SESSRLS_DROPSESS_FORCE + nikeda 04/12/04 - [OCI Events] Add OCI_ATTR_USER_MEMORY + aahluwal 04/12/04 - add OCI_HNDLFR_RESERVED5 + jciminsk 04/28/04 - merge from RDBMS_MAIN_SOLARIS_040426 + jacao 03/06/04 - add OCI_ATTR_CURRENT_SCHEMA + aahluwal 01/20/04 - remove OCI_KEEP_FETCH_STATE + aahluwal 03/25/04 - [OCI Events] add OCI_HTYPE_HAEVENT and related attrs + nikeda 03/19/04 - [OCI Events] Add OCI_ATTR_HACBK and OCI_ATTR_HACTX + dfrumkin 12/04/03 - Add database startup/shutdown + chliang 12/22/03 - grid/main merge: add OCI_ATTR_RESERVED_20 + jciminsk 12/12/03 - merge from RDBMS_MAIN_SOLARIS_031209 + sgollapu 09/19/03 - Add fetch modes + sgollapu 07/30/03 - Add TSM attributes + sgollapu 06/26/03 - Add OCI_MUTEX_TRY + aime 06/23/03 - sync grid with main + sgollapu 06/07/03 - Add reserved attribute + sgollapu 06/05/03 - Add reserved auth flag + rpingte 05/22/03 - Add OCI_ATCH_RESERVED_5 + sgollapu 05/06/03 - Add TSM attributes + sgollapu 04/10/03 - Session migration Flags/interfaces + dfrumkin 04/23/04 - add OCI_PREP2_RESERVED_1 + rpingte 05/06/04 - add major and minor version information + bsinha 04/06/04 - add new OCI_TRANS flag + chliang 11/26/03 - add OCI_ATTR_RESERVED_19 + preilly 10/23/03 - Make OCI_ATTR_DIRPATH_METADATA_BUF private + chliang 08/07/03 - add OCI_ATTR_SKIP_BUFFER + srseshad 03/12/03 - convert public oci api to ansi + weiwang 05/14/03 - remove iot creation for rule sets + rkoti 04/15/03 - [2746515] add fntcodes for Unlimited size LOB 6003 + tcruanes 05/13/03 - add slave SQL OCI execution mode + rkoti 02/21/03 - [2761455] add OCI_FNCODE_AQENQARRAY, + OCI_FNCODE_AQDEQARRAY and update OCI_FNCODE_MAXFCN + tkeefe 01/29/03 - bug-2773794: Add new interface for setting Kerb attrs + aahluwal 02/06/03 - add OCI_ATTR_TRANSFORMATION_NO + weiwang 12/05/02 - add OCI_ATTR_USER_PROPERTY + ataracha 01/03/03 - include ocixmldb.h + preilly 12/05/02 - Add wait attribute for locking when using dir path + tkeefe 01/03/03 - bug-2623771: Added OCI_ATTR_KERBEROS_KEY + lchidamb 12/13/02 - end-to-end tracing attributes + msakayed 10/28/02 - Bug #2643907: add OCI_ATTR_DIRPATH_SKIPINDEX_METHOD + rphillip 11/13/02 - Add OCIP_ATTR_DIRPATH_INDEX + sagrawal 10/13/02 - liniting + sagrawal 10/03/02 - PL/SQL Compiler warnings + jstenois 11/07/02 - remove ocixad.h + chliang 10/21/02 - add OCI_ATTR_RESERVED_16,17 + hsbedi 10/30/02 - grabtrans 'jstenois_fix_xt_convert' + aahluwal 10/12/02 - add OCI_ATTR_AQ_NUM_E_ERRORS/OCI_ATTR_AQ_ERROR_INDEX + bdagevil 10/21/02 - add SQL analyze internal exec mode + csteinba 10/11/02 - add OCI_ATTR_RESERVED_16 + chliang 10/12/02 - add bind row callback attributes + preilly 10/25/02 - Add new reserved parameters + tkeefe 10/31/02 - bug-2623771: Added OCI_ATTR_AUDIT_SESSION_ID + csteinba 10/04/02 - Add OCI_ATTR_RESERVED_15 + mhho 10/11/02 - add new credential constant + thoang 09/25/02 - Add OCI_XMLTYPE_CREATE_CLOB + skaluska 10/07/02 - describe rules objects + csteinba 09/16/02 - Remove OCI_CACHE + gtarora 10/03/02 - OCI_ATTR_COL_SUBS => OCI_ATTR_OBJ_SUBS + msakayed 09/09/02 - Bug #2482469: add OCI_ATTR_DIRPATH_RESERVED_[3-6] + aahluwal 08/30/02 - adding dequeue across txn group + srseshad 04/24/02 - Add attribute OCI_ATTR_SPOOL_STMTCACHESIZE. + ebatbout 07/22/02 - Remove OCI_ATTR_RESERVED_11. + abande 01/17/02 - Bug 1788921; Add external attribute. + aahluwal 06/04/02 - bug 2360115 + pbagal 05/24/02 - Incorporate review comments + pbagal 05/22/02 - Introduce instance type attribute. + whe 07/01/02 - add OCI_BIND_DEFINE_SOFT flags + gtarora 07/01/02 - Add OCI_ATTR_COL_SUBS + tkeefe 05/30/02 - Add support for new proxy authentication credentials + dgprice 12/18/01 - bug 2102779 add reserved force describe + schandir 11/19/01 - add/modify modes. + schandir 11/15/01 - add OCI_SPC_STMTCACHE. + schandir 12/06/01 - change mode value of OCI_SPOOL. + msakayed 11/02/01 - Bug #2094292: add OCI_ATTR_DIRPATH_INPUT + dsaha 11/09/01 - add OCI_DTYPE_RESERVED1 + skabraha 11/05/01 - new method flag + skabraha 10/25/01 - another flag for XML + skabraha 10/11/01 - describe flags for subtypes + nbhatt 09/18/01 - new reserved AQ flags + celsbern 10/19/01 - merge LOG to MAIN + ksurlake 10/12/01 - add OCI_ATTR_RESERVED_13 + ksurlake 08/13/01 - add OCI_ATTR_RESERVED_12 + schandir 09/24/01 - Adding stmt caching + abande 09/04/01 - Adding session pooling + sagrawal 10/23/01 - add new bit for OCIPHandleFree + preilly 10/25/01 - Add support for specifying metadata on DirPathCtx + skabraha 09/24/01 - describe flags for XML type + schandir 09/24/01 - Adding stmt caching + abande 09/04/01 - Adding session pooling + stakeda 09/17/01 - add OCI_NLS_CHARSET_ID + whe 09/19/01 - add OCIXMLType create options + rpingte 09/11/01 - add OCI_MUTEX_ENV_ONLY and OCI_NO_MUTEX_STMT + cmlim 08/28/01 - mod datecache attrs to use same naming as dpapi attrs + wzhang 08/24/01 - Add new keywords for OCINlsNameMap. + rphillip 05/02/01 - Add date cache attributes + rphillip 08/22/01 - Add new stream version + ebatbout 04/13/01 - add definition, OCI_ATTR_RESERVED_11 + chliang 04/12/01 - add shortnames for newer oci funcation + wzhang 04/11/01 - Add new OCI NLS constants. + cmlim 04/13/01 - remove attrs not used by dpapi (151 & 152 avail) + rkambo 03/23/01 - bugfix 1421793 + cmlim 04/02/01 - remove OCI_ATTR_DIRPATH_{NESTED_TBL, SUBST_OBJ_TBL} + - note: attribute #s 186 & 205 available + whe 03/28/01 - add OCI_AFC_PAD_ON/OFF mode + preilly 03/05/01 - Add stream versioning support to DirPath context + schandir 12/18/00 - remove attr CONN_INCR_DELAY. + schandir 12/12/00 - change mode from OCI_POOL to OCI_CPOOL. + cbarclay 01/12/01 - add atribute for OCIP_ATTR_TMZ + whe 01/07/01 - add attributes related to UTF16 env mode + slari 12/29/00 - add blank line + slari 12/28/00 - OCI_ATTR_RESERVED_10 + whe 12/19/00 - add OCI_ENVCR_RESERVED3 + rpang 11/29/00 - Added OCI_ATTR_ORA_DEBUG_JDWP attribute + cmlim 11/28/00 - support substitutable object tables in dpapi + akatti 10/09/00 - [198379]:add OCIRowidToChar + sgollapu 10/11/00 - Add OCI_PREP_RESERVED_1 + sgollapu 08/27/00 - add attribute to get erroneous column + sgollapu 07/29/00 - Add snapshot attributes + kmohan 09/18/00 - add OCI_FNCODE_LOGON2 + abrumm 10/08/00 - include ocixad.h + mbastawa 10/04/00 - add OCI_ATTR_ROWS_FETCHED + nbhatt 08/24/00 - add transformation attribute + dmwong 08/22/00 - OCI_ATTR_CID_VALUE -> OCI_ATTR_CLIENT_IDENTIFIER. + cmlim 08/30/00 - add OCI_ATTR_DIRPATH_SID + dsaha 08/18/00 - add OCI_ATTR_RESERVED_5 + amangal 08/17/00 - Merge into 8.2 : 1194361 + slari 08/03/00 - add OCI_ATTR_HANDLE_POSITION + dsaha 07/20/00 - 2rt exec + sgollapu 07/04/00 - Add virtual session flag + cmlim 07/07/00 - add OCI_ATTR_DIRPATH_OID, OCI_ATTR_DIRPATH_NESTED_TBL + etucker 07/28/00 - add OCIIntervalFromTZ + rwessman 06/26/00 - N-tier: added new credential attributes + whe 07/27/00 - add OCI_UTF16 mode + vjayaram 07/18/00 - add connection pooling changes + etucker 07/12/00 - add dls apis + cmlim 07/07/00 - add OCI_ATTR_DIRPATH_OID, OCI_ATTR_DIRPATH_NESTED_TBL + sgollapu 07/04/00 - Add virtual session flag + najain 05/01/00 - AQ Signature support + sgollapu 06/14/00 - Add reserved OCI mode + rkambo 06/08/00 - notification presentation support + sagrawal 06/04/00 - ref cursor to c + ksurlake 06/07/00 - define OCI_POOL + mbastawa 06/05/00 - added scrollable cursor attributes + weiwang 03/31/00 - add LDAP support + whe 05/30/00 - add OCI_ATTR_MAXCHAR_SIZE + whe 05/23/00 - validate OCI_NO_CACHE mode + dsaha 02/02/00 - Add no-cache attr in statement handle + whe 05/23/00 - add OCIP_ICACHE + allee 05/17/00 - describe support for JAVA implmented TYPE + preilly 05/30/00 - Continue adding support for objects in direct path lo + cmlim 05/16/00 - 8.2 dpapi support of ADTs + rxgovind 05/04/00 - OCIAnyDataSet changes + rkasamse 05/25/00 - add OCIAnyDataCtx + rmurthy 04/26/00 - describe support for inheritance + ksurlake 04/18/00 - Add credential type + whe 05/24/00 - add OCI_ATTR_CHAR_ attrs + rkambo 04/19/00 - subscription enhancement + rmurthy 04/26/00 - describe support for inheritance + delson 03/28/00 - add OCI_ATTR_RESERVED_2 + abrumm 03/31/00 - external table support + rkasamse 03/13/00 - add declarations for OCIAnyData + najain 02/24/00 - support for dequeue as select + dsaha 03/10/00 - Add OCI_ALWAYS_BLOCKING + esoyleme 04/25/00 - separated transactions + sgollapu 12/23/99 - OCIServerAttach extensions + slari 08/23/99 - add OCI_DTYPE_UCB + slari 08/20/99 - add OCI_UCBTYPE_REPLACE + hsbedi 08/31/99 - Memory Stats . + sgollapu 08/02/99 - oci sql routing + slari 08/06/99 - rename values for OCI_SERVER_STATUS + slari 08/02/99 - add OCI_ATTR_SERVER_STATUS + tnbui 07/28/99 - Remove OCI_DTYPE_TIMESTAMP_ITZ + amangal 07/19/99 - Merge into 8.1.6 : bug 785797 + tnbui 07/07/99 - Change ADJUSTMENT modes + dsaha 07/07/99 - OCI_SAHRED_EXT + dmwong 06/08/99 - add OCI_ATTR_APPCTX_* + vyanaman 06/23/99 - + vyanaman 06/21/99 - Add new OCI Datetime and Interval descriptors + esoyleme 06/29/99 - expose MTS performance enhancements + rshaikh 04/23/99 - add OCI_SQL_VERSION_* + tnbui 05/24/99 - Remove OCIAdjStr + dsaha 05/21/99 - Add OCI_ADJUST_UNK + mluong 05/17/99 - fix merge + tnbui 04/05/99 - ADJUSTMENT values + abrumm 04/16/99 - dpapi: more attributes + dsaha 02/24/99 - Add OCI_SHOW_DML_WARNINGS + jiyang 12/07/98 - Add OCI_NLS_DUAL_CURRENCY + slari 12/07/98 - change OCI_NOMUTEX to OCI_NO_MUTEX + aroy 11/30/98 - change OCI_NOCALLBACK to OCI_NO_UCB + aroy 11/13/98 - add env modes to process modes + slari 09/08/98 - add OCI_FNCODE_SVC2HST and _SVCRH + aroy 09/04/98 - Add OCI_ATTR_MIGSESSION + skray 08/14/98 - server groups for session switching + mluong 08/11/98 - add back OCI_HTYPE_LAST. + aroy 05/25/98 - add process handle type + aroy 04/06/98 - add shared mode + slari 07/13/98 - merge forward to 8.1.4 + slari 07/09/98 - add OCI_BIND_RESERVED_2 + slari 07/08/98 - add OCI_EXACT_FETCH_RESERVED_1 + dsaha 07/07/98 - Add OCI_PARSE_ONLY + dsaha 06/29/98 - Add OCI_PARSE_ONLY + slari 07/01/98 - add OCI_BIND_RESERVED_2 + sgollapu 06/25/98 - Fix bug 683565 + slari 06/17/98 - remove OC_FETCH_RESERVED_2 + slari 06/11/98 - add OCI_FETCH_RESERVED_1 and 2 + jhasenbe 05/27/98 - Remove definitions for U-Calls (Unicode) + jiyang 05/18/98 - remove OCI_ATTR_CARTLANG + nbhatt 05/20/98 - OCI_DEQ_REMOVE_NODATA + nbhatt 05/19/98 - correct AQ opcode + skmishra 05/06/98 - Add precision attribute to Attributes list + aroy 04/20/98 - merge forward 8.0.5 -> 8.1.3 + schandra 05/01/98 - OCI sender id + sgollapu 02/19/98 - enhanced array DML + nbhatt 05/15/98 - AQ listen call + sgollapu 04/27/98 - more attributes + skaluska 04/06/98 - Add OCI_PTYPE_SCHEMA, OCI_PTYPE_DATABASE + slari 04/28/98 - add OCI_ATTR_PDPRC + lchidamb 05/05/98 - change OCI_NAMESPACE_AQ to 1 + nbhatt 04/27/98 - AQ Notification Descriptor + abrumm 06/24/98 - more direct path attributes + abrumm 05/27/98 - OCI direct path interface support + abrumm 05/08/98 - OCI direct path interface support + lchidamb 03/02/98 - client notification additions + kkarun 04/17/98 - Add more Interval functions + vyanaman 04/16/98 - Add get/set TZ + kkarun 04/14/98 - Add OCI Datetime shortnames + vyanaman 04/13/98 - Add OCI DateTime and Interval check error codes + kkarun 04/07/98 - Add OCI_DTYPE_DATETIME and OCI_DTYPE_INTERVAL + esoyleme 12/15/97 - support failover callback retry + esoyleme 04/22/98 - merge support for failover callback retry + mluong 04/16/98 - add OCI_FNCODE_LOBLOCATORASSIGN + rkasamse 04/17/98 - add short names for OCIPickler(Memory/Ctx) cart servi + slari 04/10/98 - add OCI_FNCODE_SVCCTXTOLDA + slari 04/09/98 - add OCI_FNCODE_RESET + slari 04/07/98 - add OCI_FNCODE_LOBFILEISOPEN + slari 04/06/98 - add OCI_FNCODE_LOBOPEN + slari 03/20/98 - change OCI_CBTYPE_xxx to OCI_UCBTYPE_xxx + slari 03/18/98 - add OCI_FNCODE_MAXFCN + slari 02/12/98 - add OCI_ENV_NO_USRCB + skabraha 04/09/98 - adding shortnames for OCIFile + rhwu 04/03/98 - Add short names for the OCIThread package + tanguyen 04/03/98 - add OCI_ATTR_xxxx for type inheritance + rkasamse 04/02/98 - add OCI_ATTR_UCI_REFRESH + nramakri 04/01/98 - Add short names for the OCIExtract package + ewaugh 03/31/98 - Add short names for the OCIFormat package. + jhasenbe 04/06/98 - Add definitions for U-Calls (Unicode) + (OCI_TEXT, OCI_UTEXT, OCI_UTEXT4) + skmishra 03/03/98 - Add OCI_ATTR_PARSE_ERROR_OFFSET + rwessman 03/11/98 - Added OCI_CRED_PROXY for proxy authentication + abrumm 03/31/98 - OCI direct path interface support + nmallava 03/03/98 - add constants for temp lob apis + skotsovo 03/05/98 - resolve merge conflicts + skotsovo 02/24/98 - add OCI_DTYPE_LOC + skaluska 01/21/98 - Add OCI_ATTR_LTYPE + rkasamse 01/06/98 - add OCI_ATTR* for obj cache enhancements + dchatter 01/08/98 - more comments + skabraha 12/02/97 - moved oci1.h to the front of include files. + jiyang 12/18/97 - Add OCI_NLS_MAX_BUFSZ + rhwu 12/02/97 - move oci1.h up + ewaugh 12/15/97 - Add short names for the OCIFormat package. + rkasamse 12/02/97 - Add a constant for memory cartridge services -- OCI_M + nmallava 12/31/97 - open/close for internal lobs + khnguyen 11/27/97 - add OCI_ATTR_LFPRECISION, OCI_ATTR_FSPRECISION + rkasamse 11/03/97 - add types for pickler cartridge services + mluong 11/20/97 - changed ubig_ora to ub4 per skotsovo + ssamu 11/14/97 - add oci1.h + jiyang 11/13/97 - Add NLS service for cartridge + esoyleme 12/15/97 - support failover callback retry + jwijaya 10/21/97 - change OCILobOffset/Length from ubig_ora to ub4 + cxcheng 07/28/97 - fix compile with SLSHORTNAME + schandra 06/25/97 - AQ OCI interface + sgollapu 07/25/97 - Add OCI_ATTR_DESC_PUBLIC + cxcheng 06/16/97 - add OCI_ATTR_TDO + skotsovo 06/05/97 - add fntcodes for lob buffering subsystem + esoyleme 05/13/97 - move failover callback prototype + skmishra 05/06/97 - stdc compiler fixes + skmishra 04/22/97 - Provide C++ compatibility + lchidamb 04/19/97 - add OCI_ATTR_SESSLANG + ramkrish 04/15/97 - Add OCI_LOB_BUFFER_(NO)FREE + sgollapu 04/18/97 - Add OCI_ATTR_TABLESPACE + skaluska 04/17/97 - Add OCI_ATTR_SUB_NAME + schandra 04/10/97 - Use long OCI names + aroy 03/27/97 - add OCI_DTYPE_FILE + sgollapu 03/26/97 - Add OCI_OTYPEs + skmishra 04/09/97 - Added constant OCI_ROWID_LEN + dchatter 03/21/97 - add attr OCI_ATTR_IN_V8_MODE + lchidamb 03/21/97 - add OCI_COMMIT_ON_SUCCESS execution mode + skmishra 03/20/97 - Added OCI_ATTR_LOBEMPTY + sgollapu 03/19/97 - Add OCI_ATTR_OVRLD_ID + aroy 03/17/97 - add postprocessing callback + sgollapu 03/15/97 - Add OCI_ATTR_PARAM + cxcheng 02/07/97 - change OCI_PTYPE codes for type method for consistenc + cxcheng 02/05/97 - add OCI_PTYPE_TYPE_RESULT + cxcheng 02/04/97 - rename OCI_PTYPE constants to be more consistent + cxcheng 02/03/97 - add OCI_ATTR, OCI_PTYPE contants for describe type + esoyleme 01/23/97 - merge neerja callback + sgollapu 12/30/96 - Remove OCI_DTYPE_SECURITY + asurpur 12/26/96 - CHanging OCI_NO_AUTH to OCI_AUTH + sgollapu 12/23/96 - Add more attrs to COL, ARG, and SEQ + sgollapu 12/12/96 - Add OCI_DESCRIBE_ONLY + slari 12/11/96 - change prototype of OCICallbackInBind + nbhatt 12/05/96 - "callback" + lchidamb 11/19/96 - handle subclassing + sgollapu 11/09/96 - OCI_PATTR_* + dchatter 11/04/96 - add attr OCI_ATTR_CHRCNT + mluong 11/01/96 - test + cxcheng 10/31/96 - add #defines for OCILobLength etc + dchatter 10/31/96 - add lob read write call back fp defs + dchatter 10/30/96 - more changes + rhari 10/30/96 - Include ociextp.h at the very end + lchidamb 10/22/96 - add fdo attribute for bind/server handle + dchatter 10/22/96 - change attr defn for prefetch parameters & lobs/file + calls + slari 10/21/96 - add OCI_ENV_NO_MUTEX + rhari 10/25/96 - Include ociextp.h + rxgovind 10/25/96 - add OCI_LOBMAXSIZE, remove OCI_FILE_READWRITE + sgollapu 10/24/96 - Correct OCILogon and OCILogoff + sgollapu 10/24/96 - Correct to OCILogon and OCILogoff + sgollapu 10/21/96 - Add ocilon and ociloff + skaluska 10/31/96 - Add OCI_PTYPE values + sgollapu 10/17/96 - correct OCI_ATTR_SVCCTX to OCI_ATTR_SERVER + rwessman 10/16/96 - Added security functions and fixed olint errors. + sthakur 10/14/96 - add more COR attributes + cxcheng 10/14/96 - re-enable LOB functions + sgollapu 10/10/96 - Add ocibdp and ocibdn + slari 10/07/96 - add back OCIRowid + aroy 10/08/96 - add typedef ocibfill for PRO*C + mluong 10/11/96 - replace OCI_ATTR_CHARSET* with OCI_ATTR_CHARSET_* + cxcheng 10/10/96 - temporarily take out #define for lob functions + sgollapu 10/02/96 - Rename OCI functions and datatypes + skotsovo 10/01/96 - move orl lob fnts to oci + aroy 09/10/96 - fix merge errors + aroy 08/19/96 - NCHAR support + jboonleu 09/05/96 - add OCI attributes for object cache + dchatter 08/20/96 - HTYPE ranges from 1-50; DTYPE from 50-255 + slari 08/06/96 - define OCI_DTYPE_ROWID + sthakur 08/14/96 - complex object support + schandra 06/17/96 - Convert XA to use new OCI + abrik 08/15/96 - OCI_ATTR_HEAPALLOC added + aroy 07/17/96 - terminology change: ocilobd => ocilobl + aroy 07/03/96 - add lob typedefs for Pro*C + slari 06/28/96 - add OCI_ATTR_STMT_TYPE + lchidamb 06/26/96 - reorg #ifndef + schandra 05/31/96 - attribute types for internal and external client name + asurpur 05/30/96 - Changing the value of mode + schandra 05/18/96 - OCI_TRANS_TWOPHASE -> 0x00000001 to 0x00100000 + slari 05/30/96 - add callback function prototypes + jbellemo 05/23/96 - remove ociisc + schandra 04/23/96 - loosely-coupled branches + asurpur 05/15/96 - New mode for ocicpw + aroy 04/24/96 - making ocihandles opaque + slari 04/18/96 - add missing defines + schandra 03/27/96 - V8OCI - add transaction related calls + dchatter 04/01/96 - add OCI_FILE options + dchatter 03/21/96 - add oci2lda conversion routines + dchatter 03/07/96 - add OCI piece definition + slari 03/12/96 - add describe attributes + slari 03/12/96 - add OCI_OTYPE_QUERY + aroy 02/28/96 - Add column attributes + slari 02/09/96 - add OCI_OBJECT + slari 02/07/96 - add OCI_HYTPE_DSC + aroy 01/10/96 - adding function code defines... + dchatter 01/03/96 - define OCI_NON_BLOCKING + dchatter 01/02/96 - Add Any descriptor + dchatter 01/02/96 - Add Select List descriptor + dchatter 12/29/95 - V8 OCI definitions + dchatter 12/29/95 - Creation + +*/ + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef ORATYPES +#include +#endif + +#ifndef OCIDFN +#include +#endif + +#ifndef OCI_ORACLE +# define OCI_ORACLE + + +/*--------------------------------------------------------------------------- + Short names provided for platforms which do not allow extended symbolic names + ---------------------------------------------------------------------------*/ + +#ifdef SLSHORTNAME +/* Translation of the long function/type names to short names for IBM only */ +/* maybe lint will use this too */ +#define OCISessionEnd ocitac +#define OCIResultSetToStmt ocirs2sh +#define OCISessionBegin ociauth +#define OCIServerAttach ociatch +#define OCIDescriptorAlloc ocigdesc +#define OCIServerDetach ocidtch +#define OCIDescriptorFree ocifdesc +#define OCIServerVersion ocivers +#define OCIDescribeAny ocidsca +#define OCIBindDynamic ocibda +#define OCIBindByName ocibdn +#define OCIBindByPos ocibdp +#define OCIErrorGet ocigdr +#define OCIBindArrayOfStruct ocibsa +#define OCIEnvInit ociinit +#define OCIBindObject ocibndt +#define OCIHandleAlloc ocighndl +#define OCIHandleFree ocifhndl +#define OCIRowidToChar ociri2c +#ifdef NEVER +#define OCIStmtBindByPos ocibndp +#define OCIStmtBindByName ocibndn +#endif +#define OCIAttrGet ocigattr +#define OCIDefineByPos ocidfne +#define OCIAttrSet ocisattr +#define OCIDefineDynamic ociddf +#define OCILdaToSvcCtx ocild2sv +#define OCIDefineArrayOfStruct ocidarr +#define OCIInitialize ocipi +#define OCIDefineObject ocidndt +#define OCIStmtExecute ociexec +#define OCILobAppend ocilfap +#define OCILobOpenFile ocifopn +#define OCILobCloseFile ocifcls +#define OCILobLocator ocilobd +#define OCILobGetDeduplicateRegions ocilgshr +#define OCILobRegion ocilregd +#define OCILobCopy ocilfcp +#define OCILobFileCreate ocifcrt +#define OCILobFileDelete ocifdel +#define OCILobGetLength ocilfln +#define OCILobWrite ocilfwr +#define OCILobRead ocilfrd +#define OCILobErase ocilfer +#define OCILobTrim ocilftr +#define OCILobSetOptions ocinglso +#define OCILobGetOptions ocinglgo +#define OCILobFragmentInsert ocinglfi +#define OCILobFragmentDelete ocinglfd +#define OCILobFragmentMove ocinglfm +#define OCILobFragmentReplace ocinglfr +#define OCILobSetContentType ocinglsct +#define OCILobGetContentType ocinglgct + +#define OCIStmtFetch ocifch +#define OCIStmtGetBindInfo ocigbp +#define OCIStmtGetPieceInfo ocigpi +#define OCIStmtPrepare ocireq +#define OCIStmtSetPieceInfo ocispi +#define OCISvcCtxToLda ocisv2ld +#define OCITransCommit ocitxcm +#define OCITransDetach ocitxdt +#define OCITransForget ocitxfgt +#define OCITransPrepare ocitxpre +#define OCITransRollback ocitxrl +#define OCIPasswordChange ocicpw +#define OCITransStart ocitxst +#define OCITransMultiPrepare ocitxmp + +#define OCIBreak ocibreak +#define OCIParamGet ocigparm +#define OCIParamSet ocisparm + +#define OCISecurityOpenWallet ocizwOpenWallet +#define OCISecurityCloseWallet ocizwCloseWallet +#define OCISecurityCreateWallet ocizwCreateWallet +#define OCISecurityDestroyWallet ocizwDestroyWallet +#define OCISecurityStorePersona ocizeStorePersona +#define OCISecurityOpenPersona ocizeOpenPersona +#define OCISecurityClosePersona ocizeClosePersona +#define OCISecurityRemovePersona ocizeRemovePersona +#define OCISecurityCreatePersona ocizeCreatePersona +#define OCISecuritySetProtection ocizeSetProtection +#define OCISecurityGetProtection ocizeGetProtection +#define OCISecurityRemoveIdentity ociziRemoveIdentity +#define OCISecurityCreateIdentity ociziCreateIdentity +#define OCISecurityAbortIdentity ociziAbortIdentity +#define OCISecurityFreeIdentity ociziFreeIdentity +#define OCISecurityStoreTrustedIdentity ociziStoreTrustedIdentity +#define OCISecuritySign ocizSign +#define OCISecuritySignExpansion ocizxSignExpansion +#define OCISecurityVerify ocizVerify +#define OCISecurityValidate ocizValidate +#define OCISecuritySignDetached ocizsd_SignDetached +#define OCISecuritySignDetExpansion ocizxsd_SignDetachedExpansion +#define OCISecurityVerifyDetached ocizved_VerifyDetached +#define OCISecurity_PKEncrypt ocizkec_PKEncrypt +#define OCISecurityPKEncryptExpansion ocizxkec_PKEncryptExpansion +#define OCISecurityPKDecrypt ocizkdc_PKDecrypt +#define OCISecurityEncrypt ocizEncrypt +#define OCISecurityEncryptExpansion ocizxEncryptExpansion +#define OCISecurityDecrypt ocizDecrypt +#define OCISecurityEnvelope ocizEnvelope +#define OCISecurityDeEnvelope ocizDeEnvelope +#define OCISecurityKeyedHash ocizKeyedHash +#define OCISecurityKeyedHashExpansion ocizxKeyedHashExpansion +#define OCISecurityHash ocizHash +#define OCISecurityHashExpansion ocizxHashExpansion +#define OCISecuritySeedRandom ocizSeedRandom +#define OCISecurityRandomBytes ocizrb_RandomBytes +#define OCISecurityRandomNumber ocizrn_RandomNumber +#define OCISecurityInitBlock ocizibInitBlock +#define OCISecurityReuseBlock ocizrbReuseBlock +#define OCISecurityPurgeBlock ocizpbPurgeBlock +#define OCISecuritySetBlock ocizsbSetBlock +#define OCISecurityGetIdentity ocizgi_GetIdentity + +#define OCIExtractInit ocixeini +#define OCIExtractTerm ocixetrm +#define OCIExtractReset ocixerst +#define OCIExtractSetNumKeys ocixesnk +#define OCIExtractSetKey ocixesk +#define OCIExtractFromFile ocixeff +#define OCIExtractFromStr ocixefs +#define OCIExtractToInt ocixeti +#define OCIExtractToBool ocixetb +#define OCIExtractToStr ocixets +#define OCIExtractToOCINum ocixeton +#define OCIExtractToList ocixetl +#define OCIExtractFromList ocixefl + +#define OCIDateTimeGetTime ocidt01_GetTime +#define OCIDateTimeGetDate ocidt02_GetDate +#define OCIDateTimeGetTimeZoneOffset ocidt03_GetTZ +#define OCIDateTimeSysTimeStamp ocidt07_SysTS +#define OCIDateTimeAssign ocidt08_Assign +#define OCIDateTimeToText ocidt09_ToText +#define OCIDateTimeFromText ocidt10_FromText +#define OCIDateTimeCompare ocidt11_Compare +#define OCIDateTimeCheck ocidt12_Check +#define OCIDateTimeConvert ocidt13_Convert +#define OCIDateTimeSubtract ocidt14_Subtract +#define OCIDateTimeIntervalAdd ocidt15_IntervalAdd +#define OCIDateTimeIntervalSub ocidt16_IntervalSub +#define OCIDateTimeGetTimeZoneName ocidt17_Gettzname +#define OCIDateTimeToArray ocidt18_ToArray +#define OCIDateTimeFromArray ocidt19_FromArray + +#define OCIIntervalSubtract ociint01_Subtract +#define OCIIntervalAdd ociint02_Add +#define OCIIntervalMultiply ociint03_Multiply +#define OCIIntervalDivide ociint04_Divide +#define OCIIntervalCompare ociint05_Compare +#define OCIIntervalFromText ociint06_FromText +#define OCIIntervalToText ociint07_ToText +#define OCIIntervalToNumber ociint08_ToNumber +#define OCIIntervalCheck ociint09_Check +#define OCIIntervalAssign ociint10_Assign +#define OCIIntervalGetYearMonth ociint11_GetYearMonth +#define OCIIntervalSetYearMonth ociint12_SetYearMonth +#define OCIIntervalGetDaySecond ociint13_GetDaySecond +#define OCIIntervalSetDaySecond ociint14_SetDaySecond +#define OCIIntervalFromNumber ociint15_FromNumber +#define OCIIntervalFromTZ ociint16_FromTZ + +#define OCIFormatInit ocixs01_Init +#define OCIFormatString ocixs02_Format +#define OCIFormatTerm ocixs03_Term +#define OCIFormatTUb1 ocixs04_TUb1 +#define OCIFormatTUb2 ocixs05_TUb2 +#define OCIFormatTUb4 ocixs06_TUb4 +#define OCIFormatTUword ocixs07_TUword +#define OCIFormatTUbig_ora ocixs08_TUbig_ora +#define OCIFormatTSb1 ocixs09_TSb1 +#define OCIFormatTSb2 ocixs10_TSb2 +#define OCIFormatTSb4 ocixs11_TSb4 +#define OCIFormatTSword ocixs12_TSword +#define OCIFormatTSbig_ora ocixs13_TSbig_ora +#define OCIFormatTEb1 ocixs14_TEb1 +#define OCIFormatTEb2 ocixs15_TEb2 +#define OCIFormatTEb4 ocixs16_TEb4 +#define OCIFormatTEword ocixs17_TEword +#define OCIFormatTChar ocixs18_TChar +#define OCIFormatTText ocixs19_TText +#define OCIFormatTDouble ocixs20_TDouble +#define OCIFormatTDvoid ocixs21_TDvoid +#define OCIFormatTEnd ocixs22_TEnd + +#define OCIFileInit ocifinit +#define OCIFileTerm ocifterm +#define OCIFileOpen ocifopen +#define OCIFileClose ocifclose +#define OCIFileRead ocifread +#define OCIFileWrite ocifwrite +#define OCIFileSeek ocifseek +#define OCIFileExists ocifexists +#define OCIFileGetLength ocifglen +#define OCIFileFlush ocifflush + + +/* OCIThread short name */ +#define OCIThreadProcessInit ocitt01_ProcessInit +#define OCIThreadInit ocitt02_Init +#define OCIThreadTerm ocitt03_Term +#define OCIThreadIsMulti ocitt04_IsMulti +#define OCIThreadMutexInit ocitt05_MutexInit +#define OCIThreadMutexDestroy ocitt06_MutexDestroy +#define OCIThreadMutexAcquire ocitt07_MutexAcquire +#define OCIThreadMutexRelease ocitt08_MutexRelease +#define OCIThreadKeyInit ocitt09_KeyInit +#define OCIThreadKeyDestroy ocitt10_KeyDestroy +#define OCIThreadKeyGet ocitt11_KeyGet +#define OCIThreadKeySet ocitt12_KeySet +#define OCIThreadIdInit ocitt13_IdInit +#define OCIThreadIdDestroy ocitt14_IdDestroy +#define OCIThreadIdSet ocitt15_IdSet +#define OCIThreadIdSetNull ocitt16_IdSetNull +#define OCIThreadIdGet ocitt17_IdGet +#define OCIThreadIdSame ocitt18_IdSame +#define OCIThreadIdNull ocitt19_IdNull +#define OCIThreadHndInit ocitt20_HndInit +#define OCIThreadHndDestroy ocitt21_HndDestroy +#define OCIThreadCreate ocitt22_Create +#define OCIThreadJoin ocitt23_Join +#define OCIThreadClose ocitt24_Close +#define OCIThreadHandleGet ocitt25_HandleGet + +/* Translation between the old and new datatypes */ + +#define OCISession ociusrh +#define OCIBind ocibndh +#define OCIDescribe ocidsch +#define OCIDefine ocidfnh +#define OCIEnv ocienvh +#define OCIError ocierrh + +#define OCICPool ocicpool + +#define OCISPool ocispool +#define OCIAuthInfo ociauthinfo + + +#define OCILob ocilobd +#define OCILobLength ocillen +#define OCILobMode ocilmo +#define OCILobOffset ociloff + +#define OCILobLocator ocilobd +#define OCIBlobLocator ociblobl +#define OCIClobLocator ociclobl +#define OCILobRegion ocilregd +#define OCIBFileLocator ocibfilel + +#define OCIParam ocipard +#define OCIResult ocirstd +#define OCISnapshot ocisnad +#define OCIServer ocisrvh +#define OCIStmt ocistmh +#define OCISvcCtx ocisvch +#define OCITrans ocitxnh +#define OCICallbackInBind ocibicfp +#define OCICallbackOutBind ocibocfp +#define OCICallbackDefine ocidcfp +#define OCICallbackLobRead ocilrfp +#define OCICallbackLobWrite ocilwfp +#define OCICallbackLobGetDededuplicateRegions ocilgshr +#define OCISecurity ociossh +#define OCIComplexObject ocicorh +#define OCIComplexObjectComp ocicord +#define OCIRowid ociridd + +#define OCIAQDeq ociaqdeq +#define OCIAQEnq ociaqenq +#define OCIConnectionPoolCreate ociconpc +#define OCIConnectionPoolDestroy ociconpd +#define OCIEnvCreate ocienvct +#define OCILobAssign ociloass +#define OCILobCharSetForm ocilocfm +#define OCILobCharSetId ocilocid +#define OCILobDisableBuffering ocilodbf +#define OCILobEnableBuffering ociloebf +#define OCILobFileClose ocilofcl +#define OCILobFileCloseAll ocilofca +#define OCILobFileExists ocilofex +#define OCILobFileGetName ocilofgn +#define OCILobFileIsOpen ocifiopn +#define OCILobFileOpen ocilofop +#define OCILobFileSetName ocilofsn +#define OCILobFlushBuffer ocilofbf +#define OCILobIsEqual ociloieq +#define OCILobLoadFromFile ocilolff +#define OCILobLocatorIsInit ocilolii +#define OCILobLocatorAssign ocilolas +#define OCILogon ocilogon +#define OCILogon2 ocilgon2 +#define OCILogoff ocilgoff +#endif /* ifdef SLSHORTNAME */ + +/*--------------------------------------------------------------------------- + PUBLIC TYPES AND CONSTANTS + ---------------------------------------------------------------------------*/ + +/*-----------------------------Handle Types----------------------------------*/ + /* handle types range from 1 - 49 */ +#define OCI_HTYPE_FIRST 1 /* start value of handle type */ +#define OCI_HTYPE_ENV 1 /* environment handle */ +#define OCI_HTYPE_ERROR 2 /* error handle */ +#define OCI_HTYPE_SVCCTX 3 /* service handle */ +#define OCI_HTYPE_STMT 4 /* statement handle */ +#define OCI_HTYPE_BIND 5 /* bind handle */ +#define OCI_HTYPE_DEFINE 6 /* define handle */ +#define OCI_HTYPE_DESCRIBE 7 /* describe handle */ +#define OCI_HTYPE_SERVER 8 /* server handle */ +#define OCI_HTYPE_SESSION 9 /* authentication handle */ +#define OCI_HTYPE_AUTHINFO OCI_HTYPE_SESSION /* SessionGet auth handle */ +#define OCI_HTYPE_TRANS 10 /* transaction handle */ +#define OCI_HTYPE_COMPLEXOBJECT 11 /* complex object retrieval handle */ +#define OCI_HTYPE_SECURITY 12 /* security handle */ +#define OCI_HTYPE_SUBSCRIPTION 13 /* subscription handle */ +#define OCI_HTYPE_DIRPATH_CTX 14 /* direct path context */ +#define OCI_HTYPE_DIRPATH_COLUMN_ARRAY 15 /* direct path column array */ +#define OCI_HTYPE_DIRPATH_STREAM 16 /* direct path stream */ +#define OCI_HTYPE_PROC 17 /* process handle */ +#define OCI_HTYPE_DIRPATH_FN_CTX 18 /* direct path function context */ +#define OCI_HTYPE_DIRPATH_FN_COL_ARRAY 19 /* dp object column array */ +#define OCI_HTYPE_XADSESSION 20 /* access driver session */ +#define OCI_HTYPE_XADTABLE 21 /* access driver table */ +#define OCI_HTYPE_XADFIELD 22 /* access driver field */ +#define OCI_HTYPE_XADGRANULE 23 /* access driver granule */ +#define OCI_HTYPE_XADRECORD 24 /* access driver record */ +#define OCI_HTYPE_XADIO 25 /* access driver I/O */ +#define OCI_HTYPE_CPOOL 26 /* connection pool handle */ +#define OCI_HTYPE_SPOOL 27 /* session pool handle */ +#define OCI_HTYPE_ADMIN 28 /* admin handle */ +#define OCI_HTYPE_EVENT 29 /* HA event handle */ + +#define OCI_HTYPE_LAST 29 /* last value of a handle type */ + +/*---------------------------------------------------------------------------*/ + + +/*-------------------------Descriptor Types----------------------------------*/ + /* descriptor values range from 50 - 255 */ +#define OCI_DTYPE_FIRST 50 /* start value of descriptor type */ +#define OCI_DTYPE_LOB 50 /* lob locator */ +#define OCI_DTYPE_SNAP 51 /* snapshot descriptor */ +#define OCI_DTYPE_RSET 52 /* result set descriptor */ +#define OCI_DTYPE_PARAM 53 /* a parameter descriptor obtained from ocigparm */ +#define OCI_DTYPE_ROWID 54 /* rowid descriptor */ +#define OCI_DTYPE_COMPLEXOBJECTCOMP 55 + /* complex object retrieval descriptor */ +#define OCI_DTYPE_FILE 56 /* File Lob locator */ +#define OCI_DTYPE_AQENQ_OPTIONS 57 /* enqueue options */ +#define OCI_DTYPE_AQDEQ_OPTIONS 58 /* dequeue options */ +#define OCI_DTYPE_AQMSG_PROPERTIES 59 /* message properties */ +#define OCI_DTYPE_AQAGENT 60 /* aq agent */ +#define OCI_DTYPE_LOCATOR 61 /* LOB locator */ +#define OCI_DTYPE_INTERVAL_YM 62 /* Interval year month */ +#define OCI_DTYPE_INTERVAL_DS 63 /* Interval day second */ +#define OCI_DTYPE_AQNFY_DESCRIPTOR 64 /* AQ notify descriptor */ +#define OCI_DTYPE_DATE 65 /* Date */ +#define OCI_DTYPE_TIME 66 /* Time */ +#define OCI_DTYPE_TIME_TZ 67 /* Time with timezone */ +#define OCI_DTYPE_TIMESTAMP 68 /* Timestamp */ +#define OCI_DTYPE_TIMESTAMP_TZ 69 /* Timestamp with timezone */ +#define OCI_DTYPE_TIMESTAMP_LTZ 70 /* Timestamp with local tz */ +#define OCI_DTYPE_UCB 71 /* user callback descriptor */ +#define OCI_DTYPE_SRVDN 72 /* server DN list descriptor */ +#define OCI_DTYPE_SIGNATURE 73 /* signature */ +#define OCI_DTYPE_RESERVED_1 74 /* reserved for internal use */ +#define OCI_DTYPE_AQLIS_OPTIONS 75 /* AQ listen options */ +#define OCI_DTYPE_AQLIS_MSG_PROPERTIES 76 /* AQ listen msg props */ +#define OCI_DTYPE_CHDES 77 /* Top level change notification desc */ +#define OCI_DTYPE_TABLE_CHDES 78 /* Table change descriptor */ +#define OCI_DTYPE_ROW_CHDES 79 /* Row change descriptor */ +#define OCI_DTYPE_CQDES 80 /* Query change descriptor */ +#define OCI_DTYPE_LOB_REGION 81 /* LOB Share region descriptor */ +#define OCI_DTYPE_LAST 81 /* last value of a descriptor type */ + +/*---------------------------------------------------------------------------*/ + +/*--------------------------------LOB types ---------------------------------*/ +#define OCI_TEMP_BLOB 1 /* LOB type - BLOB ------------------ */ +#define OCI_TEMP_CLOB 2 /* LOB type - CLOB ------------------ */ +/*---------------------------------------------------------------------------*/ + +/*-------------------------Object Ptr Types----------------------------------*/ +#define OCI_OTYPE_NAME 1 /* object name */ +#define OCI_OTYPE_REF 2 /* REF to TDO */ +#define OCI_OTYPE_PTR 3 /* PTR to TDO */ +/*---------------------------------------------------------------------------*/ + +/*=============================Attribute Types===============================*/ +/* + Note: All attributes are global. New attibutes should be added to the end + of the list. Before you add an attribute see if an existing one can be + used for your handle. + + If you see any holes please use the holes first. + +*/ +/*===========================================================================*/ + + +#define OCI_ATTR_FNCODE 1 /* the OCI function code */ +#define OCI_ATTR_OBJECT 2 /* is the environment initialized in object mode */ +#define OCI_ATTR_NONBLOCKING_MODE 3 /* non blocking mode */ +#define OCI_ATTR_SQLCODE 4 /* the SQL verb */ +#define OCI_ATTR_ENV 5 /* the environment handle */ +#define OCI_ATTR_SERVER 6 /* the server handle */ +#define OCI_ATTR_SESSION 7 /* the user session handle */ +#define OCI_ATTR_TRANS 8 /* the transaction handle */ +#define OCI_ATTR_ROW_COUNT 9 /* the rows processed so far */ +#define OCI_ATTR_SQLFNCODE 10 /* the SQL verb of the statement */ +#define OCI_ATTR_PREFETCH_ROWS 11 /* sets the number of rows to prefetch */ +#define OCI_ATTR_NESTED_PREFETCH_ROWS 12 /* the prefetch rows of nested table*/ +#define OCI_ATTR_PREFETCH_MEMORY 13 /* memory limit for rows fetched */ +#define OCI_ATTR_NESTED_PREFETCH_MEMORY 14 /* memory limit for nested rows */ +#define OCI_ATTR_CHAR_COUNT 15 + /* this specifies the bind and define size in characters */ +#define OCI_ATTR_PDSCL 16 /* packed decimal scale */ +#define OCI_ATTR_FSPRECISION OCI_ATTR_PDSCL + /* fs prec for datetime data types */ +#define OCI_ATTR_PDPRC 17 /* packed decimal format */ +#define OCI_ATTR_LFPRECISION OCI_ATTR_PDPRC + /* fs prec for datetime data types */ +#define OCI_ATTR_PARAM_COUNT 18 /* number of column in the select list */ +#define OCI_ATTR_ROWID 19 /* the rowid */ +#define OCI_ATTR_CHARSET 20 /* the character set value */ +#define OCI_ATTR_NCHAR 21 /* NCHAR type */ +#define OCI_ATTR_USERNAME 22 /* username attribute */ +#define OCI_ATTR_PASSWORD 23 /* password attribute */ +#define OCI_ATTR_STMT_TYPE 24 /* statement type */ +#define OCI_ATTR_INTERNAL_NAME 25 /* user friendly global name */ +#define OCI_ATTR_EXTERNAL_NAME 26 /* the internal name for global txn */ +#define OCI_ATTR_XID 27 /* XOPEN defined global transaction id */ +#define OCI_ATTR_TRANS_LOCK 28 /* */ +#define OCI_ATTR_TRANS_NAME 29 /* string to identify a global transaction */ +#define OCI_ATTR_HEAPALLOC 30 /* memory allocated on the heap */ +#define OCI_ATTR_CHARSET_ID 31 /* Character Set ID */ +#define OCI_ATTR_CHARSET_FORM 32 /* Character Set Form */ +#define OCI_ATTR_MAXDATA_SIZE 33 /* Maximumsize of data on the server */ +#define OCI_ATTR_CACHE_OPT_SIZE 34 /* object cache optimal size */ +#define OCI_ATTR_CACHE_MAX_SIZE 35 /* object cache maximum size percentage */ +#define OCI_ATTR_PINOPTION 36 /* object cache default pin option */ +#define OCI_ATTR_ALLOC_DURATION 37 + /* object cache default allocation duration */ +#define OCI_ATTR_PIN_DURATION 38 /* object cache default pin duration */ +#define OCI_ATTR_FDO 39 /* Format Descriptor object attribute */ +#define OCI_ATTR_POSTPROCESSING_CALLBACK 40 + /* Callback to process outbind data */ +#define OCI_ATTR_POSTPROCESSING_CONTEXT 41 + /* Callback context to process outbind data */ +#define OCI_ATTR_ROWS_RETURNED 42 + /* Number of rows returned in current iter - for Bind handles */ +#define OCI_ATTR_FOCBK 43 /* Failover Callback attribute */ +#define OCI_ATTR_IN_V8_MODE 44 /* is the server/service context in V8 mode */ +#define OCI_ATTR_LOBEMPTY 45 /* empty lob ? */ +#define OCI_ATTR_SESSLANG 46 /* session language handle */ + +#define OCI_ATTR_VISIBILITY 47 /* visibility */ +#define OCI_ATTR_RELATIVE_MSGID 48 /* relative message id */ +#define OCI_ATTR_SEQUENCE_DEVIATION 49 /* sequence deviation */ + +#define OCI_ATTR_CONSUMER_NAME 50 /* consumer name */ +#define OCI_ATTR_DEQ_MODE 51 /* dequeue mode */ +#define OCI_ATTR_NAVIGATION 52 /* navigation */ +#define OCI_ATTR_WAIT 53 /* wait */ +#define OCI_ATTR_DEQ_MSGID 54 /* dequeue message id */ + +#define OCI_ATTR_PRIORITY 55 /* priority */ +#define OCI_ATTR_DELAY 56 /* delay */ +#define OCI_ATTR_EXPIRATION 57 /* expiration */ +#define OCI_ATTR_CORRELATION 58 /* correlation id */ +#define OCI_ATTR_ATTEMPTS 59 /* # of attempts */ +#define OCI_ATTR_RECIPIENT_LIST 60 /* recipient list */ +#define OCI_ATTR_EXCEPTION_QUEUE 61 /* exception queue name */ +#define OCI_ATTR_ENQ_TIME 62 /* enqueue time (only OCIAttrGet) */ +#define OCI_ATTR_MSG_STATE 63/* message state (only OCIAttrGet) */ + /* NOTE: 64-66 used below */ +#define OCI_ATTR_AGENT_NAME 64 /* agent name */ +#define OCI_ATTR_AGENT_ADDRESS 65 /* agent address */ +#define OCI_ATTR_AGENT_PROTOCOL 66 /* agent protocol */ +#define OCI_ATTR_USER_PROPERTY 67 /* user property */ +#define OCI_ATTR_SENDER_ID 68 /* sender id */ +#define OCI_ATTR_ORIGINAL_MSGID 69 /* original message id */ + +#define OCI_ATTR_QUEUE_NAME 70 /* queue name */ +#define OCI_ATTR_NFY_MSGID 71 /* message id */ +#define OCI_ATTR_MSG_PROP 72 /* message properties */ + +#define OCI_ATTR_NUM_DML_ERRORS 73 /* num of errs in array DML */ +#define OCI_ATTR_DML_ROW_OFFSET 74 /* row offset in the array */ + + /* AQ array error handling uses DML method of accessing errors */ +#define OCI_ATTR_AQ_NUM_ERRORS OCI_ATTR_NUM_DML_ERRORS +#define OCI_ATTR_AQ_ERROR_INDEX OCI_ATTR_DML_ROW_OFFSET + +#define OCI_ATTR_DATEFORMAT 75 /* default date format string */ +#define OCI_ATTR_BUF_ADDR 76 /* buffer address */ +#define OCI_ATTR_BUF_SIZE 77 /* buffer size */ + +/* For values 78 - 80, see DirPathAPI attribute section in this file */ + +#define OCI_ATTR_NUM_ROWS 81 /* number of rows in column array */ + /* NOTE that OCI_ATTR_NUM_COLS is a column + * array attribute too. + */ +#define OCI_ATTR_COL_COUNT 82 /* columns of column array + processed so far. */ +#define OCI_ATTR_STREAM_OFFSET 83 /* str off of last row processed */ +#define OCI_ATTR_SHARED_HEAPALLOC 84 /* Shared Heap Allocation Size */ + +#define OCI_ATTR_SERVER_GROUP 85 /* server group name */ + +#define OCI_ATTR_MIGSESSION 86 /* migratable session attribute */ + +#define OCI_ATTR_NOCACHE 87 /* Temporary LOBs */ + +#define OCI_ATTR_MEMPOOL_SIZE 88 /* Pool Size */ +#define OCI_ATTR_MEMPOOL_INSTNAME 89 /* Instance name */ +#define OCI_ATTR_MEMPOOL_APPNAME 90 /* Application name */ +#define OCI_ATTR_MEMPOOL_HOMENAME 91 /* Home Directory name */ +#define OCI_ATTR_MEMPOOL_MODEL 92 /* Pool Model (proc,thrd,both)*/ +#define OCI_ATTR_MODES 93 /* Modes */ + +#define OCI_ATTR_SUBSCR_NAME 94 /* name of subscription */ +#define OCI_ATTR_SUBSCR_CALLBACK 95 /* associated callback */ +#define OCI_ATTR_SUBSCR_CTX 96 /* associated callback context */ +#define OCI_ATTR_SUBSCR_PAYLOAD 97 /* associated payload */ +#define OCI_ATTR_SUBSCR_NAMESPACE 98 /* associated namespace */ + +#define OCI_ATTR_PROXY_CREDENTIALS 99 /* Proxy user credentials */ +#define OCI_ATTR_INITIAL_CLIENT_ROLES 100 /* Initial client role list */ + +#define OCI_ATTR_UNK 101 /* unknown attribute */ +#define OCI_ATTR_NUM_COLS 102 /* number of columns */ +#define OCI_ATTR_LIST_COLUMNS 103 /* parameter of the column list */ +#define OCI_ATTR_RDBA 104 /* DBA of the segment header */ +#define OCI_ATTR_CLUSTERED 105 /* whether the table is clustered */ +#define OCI_ATTR_PARTITIONED 106 /* whether the table is partitioned */ +#define OCI_ATTR_INDEX_ONLY 107 /* whether the table is index only */ +#define OCI_ATTR_LIST_ARGUMENTS 108 /* parameter of the argument list */ +#define OCI_ATTR_LIST_SUBPROGRAMS 109 /* parameter of the subprogram list */ +#define OCI_ATTR_REF_TDO 110 /* REF to the type descriptor */ +#define OCI_ATTR_LINK 111 /* the database link name */ +#define OCI_ATTR_MIN 112 /* minimum value */ +#define OCI_ATTR_MAX 113 /* maximum value */ +#define OCI_ATTR_INCR 114 /* increment value */ +#define OCI_ATTR_CACHE 115 /* number of sequence numbers cached */ +#define OCI_ATTR_ORDER 116 /* whether the sequence is ordered */ +#define OCI_ATTR_HW_MARK 117 /* high-water mark */ +#define OCI_ATTR_TYPE_SCHEMA 118 /* type's schema name */ +#define OCI_ATTR_TIMESTAMP 119 /* timestamp of the object */ +#define OCI_ATTR_NUM_ATTRS 120 /* number of sttributes */ +#define OCI_ATTR_NUM_PARAMS 121 /* number of parameters */ +#define OCI_ATTR_OBJID 122 /* object id for a table or view */ +#define OCI_ATTR_PTYPE 123 /* type of info described by */ +#define OCI_ATTR_PARAM 124 /* parameter descriptor */ +#define OCI_ATTR_OVERLOAD_ID 125 /* overload ID for funcs and procs */ +#define OCI_ATTR_TABLESPACE 126 /* table name space */ +#define OCI_ATTR_TDO 127 /* TDO of a type */ +#define OCI_ATTR_LTYPE 128 /* list type */ +#define OCI_ATTR_PARSE_ERROR_OFFSET 129 /* Parse Error offset */ +#define OCI_ATTR_IS_TEMPORARY 130 /* whether table is temporary */ +#define OCI_ATTR_IS_TYPED 131 /* whether table is typed */ +#define OCI_ATTR_DURATION 132 /* duration of temporary table */ +#define OCI_ATTR_IS_INVOKER_RIGHTS 133 /* is invoker rights */ +#define OCI_ATTR_OBJ_NAME 134 /* top level schema obj name */ +#define OCI_ATTR_OBJ_SCHEMA 135 /* schema name */ +#define OCI_ATTR_OBJ_ID 136 /* top level schema object id */ + +/* For values 137 - 141, see DirPathAPI attribute section in this file */ + + +#define OCI_ATTR_TRANS_TIMEOUT 142 /* transaction timeout */ +#define OCI_ATTR_SERVER_STATUS 143/* state of the server handle */ +#define OCI_ATTR_STATEMENT 144 /* statement txt in stmt hdl */ + +/* For value 145, see DirPathAPI attribute section in this file */ + +#define OCI_ATTR_DEQCOND 146 /* dequeue condition */ +#define OCI_ATTR_RESERVED_2 147 /* reserved */ + + +#define OCI_ATTR_SUBSCR_RECPT 148 /* recepient of subscription */ +#define OCI_ATTR_SUBSCR_RECPTPROTO 149 /* protocol for recepient */ + +/* For values 150 - 151, see DirPathAPI attribute section in this file */ + +#define OCI_ATTR_LDAP_HOST 153 /* LDAP host to connect to */ +#define OCI_ATTR_LDAP_PORT 154 /* LDAP port to connect to */ +#define OCI_ATTR_BIND_DN 155 /* bind DN */ +#define OCI_ATTR_LDAP_CRED 156 /* credentials to connect to LDAP */ +#define OCI_ATTR_WALL_LOC 157 /* client wallet location */ +#define OCI_ATTR_LDAP_AUTH 158 /* LDAP authentication method */ +#define OCI_ATTR_LDAP_CTX 159 /* LDAP adminstration context DN */ +#define OCI_ATTR_SERVER_DNS 160 /* list of registration server DNs */ + +#define OCI_ATTR_DN_COUNT 161 /* the number of server DNs */ +#define OCI_ATTR_SERVER_DN 162 /* server DN attribute */ + +#define OCI_ATTR_MAXCHAR_SIZE 163 /* max char size of data */ + +#define OCI_ATTR_CURRENT_POSITION 164 /* for scrollable result sets*/ + +/* Added to get attributes for ref cursor to statement handle */ +#define OCI_ATTR_RESERVED_3 165 /* reserved */ +#define OCI_ATTR_RESERVED_4 166 /* reserved */ + +/* For value 167, see DirPathAPI attribute section in this file */ + +#define OCI_ATTR_DIGEST_ALGO 168 /* digest algorithm */ +#define OCI_ATTR_CERTIFICATE 169 /* certificate */ +#define OCI_ATTR_SIGNATURE_ALGO 170 /* signature algorithm */ +#define OCI_ATTR_CANONICAL_ALGO 171 /* canonicalization algo. */ +#define OCI_ATTR_PRIVATE_KEY 172 /* private key */ +#define OCI_ATTR_DIGEST_VALUE 173 /* digest value */ +#define OCI_ATTR_SIGNATURE_VAL 174 /* signature value */ +#define OCI_ATTR_SIGNATURE 175 /* signature */ + +/* attributes for setting OCI stmt caching specifics in svchp */ +#define OCI_ATTR_STMTCACHESIZE 176 /* size of the stm cache */ + +/* --------------------------- Connection Pool Attributes ------------------ */ +#define OCI_ATTR_CONN_NOWAIT 178 +#define OCI_ATTR_CONN_BUSY_COUNT 179 +#define OCI_ATTR_CONN_OPEN_COUNT 180 +#define OCI_ATTR_CONN_TIMEOUT 181 +#define OCI_ATTR_STMT_STATE 182 +#define OCI_ATTR_CONN_MIN 183 +#define OCI_ATTR_CONN_MAX 184 +#define OCI_ATTR_CONN_INCR 185 + +/* For value 187, see DirPathAPI attribute section in this file */ + +#define OCI_ATTR_NUM_OPEN_STMTS 188 /* open stmts in session */ +#define OCI_ATTR_DESCRIBE_NATIVE 189 /* get native info via desc */ + +#define OCI_ATTR_BIND_COUNT 190 /* number of bind postions */ +#define OCI_ATTR_HANDLE_POSITION 191 /* pos of bind/define handle */ +#define OCI_ATTR_RESERVED_5 192 /* reserverd */ +#define OCI_ATTR_SERVER_BUSY 193 /* call in progress on server*/ + +/* For value 194, see DirPathAPI attribute section in this file */ + +/* notification presentation for recipient */ +#define OCI_ATTR_SUBSCR_RECPTPRES 195 +#define OCI_ATTR_TRANSFORMATION 196 /* AQ message transformation */ + +#define OCI_ATTR_ROWS_FETCHED 197 /* rows fetched in last call */ + +/* --------------------------- Snapshot attributes ------------------------- */ +#define OCI_ATTR_SCN_BASE 198 /* snapshot base */ +#define OCI_ATTR_SCN_WRAP 199 /* snapshot wrap */ + +/* --------------------------- Miscellanous attributes --------------------- */ +#define OCI_ATTR_RESERVED_6 200 /* reserved */ +#define OCI_ATTR_READONLY_TXN 201 /* txn is readonly */ +#define OCI_ATTR_RESERVED_7 202 /* reserved */ +#define OCI_ATTR_ERRONEOUS_COLUMN 203 /* position of erroneous col */ +#define OCI_ATTR_RESERVED_8 204 /* reserved */ +#define OCI_ATTR_ASM_VOL_SPRT 205 /* ASM volume supported? */ + +/* For value 206, see DirPathAPI attribute section in this file */ + +#define OCI_ATTR_INST_TYPE 207 /* oracle instance type */ +/******USED attribute 208 for OCI_ATTR_SPOOL_STMTCACHESIZE*******************/ + +#define OCI_ATTR_ENV_UTF16 209 /* is env in utf16 mode? */ +#define OCI_ATTR_RESERVED_9 210 /* reserved */ +#define OCI_ATTR_RESERVED_10 211 /* reserved */ + +/* For values 212 and 213, see DirPathAPI attribute section in this file */ + +#define OCI_ATTR_RESERVED_12 214 /* reserved */ +#define OCI_ATTR_RESERVED_13 215 /* reserved */ +#define OCI_ATTR_IS_EXTERNAL 216 /* whether table is external */ + + +/* -------------------------- Statement Handle Attributes ------------------ */ + +#define OCI_ATTR_RESERVED_15 217 /* reserved */ +#define OCI_ATTR_STMT_IS_RETURNING 218 /* stmt has returning clause */ +#define OCI_ATTR_RESERVED_16 219 /* reserved */ +#define OCI_ATTR_RESERVED_17 220 /* reserved */ +#define OCI_ATTR_RESERVED_18 221 /* reserved */ + +/* --------------------------- session attributes ---------------------------*/ +#define OCI_ATTR_RESERVED_19 222 /* reserved */ +#define OCI_ATTR_RESERVED_20 223 /* reserved */ +#define OCI_ATTR_CURRENT_SCHEMA 224 /* Current Schema */ +#define OCI_ATTR_RESERVED_21 415 /* reserved */ + +/* ------------------------- notification subscription ----------------------*/ +#define OCI_ATTR_SUBSCR_QOSFLAGS 225 /* QOS flags */ +#define OCI_ATTR_SUBSCR_PAYLOADCBK 226 /* Payload callback */ +#define OCI_ATTR_SUBSCR_TIMEOUT 227 /* Timeout */ +#define OCI_ATTR_SUBSCR_NAMESPACE_CTX 228 /* Namespace context */ +#define OCI_ATTR_SUBSCR_CQ_QOSFLAGS 229 + /* change notification (CQ) specific QOS flags */ +#define OCI_ATTR_SUBSCR_CQ_REGID 230 + /* change notification registration id */ +#define OCI_ATTR_SUBSCR_NTFN_GROUPING_CLASS 231/* ntfn grouping class */ +#define OCI_ATTR_SUBSCR_NTFN_GROUPING_VALUE 232/* ntfn grouping value */ +#define OCI_ATTR_SUBSCR_NTFN_GROUPING_TYPE 233 /* ntfn grouping type */ +#define OCI_ATTR_SUBSCR_NTFN_GROUPING_START_TIME 234/* ntfn grp start time */ +#define OCI_ATTR_SUBSCR_NTFN_GROUPING_REPEAT_COUNT 235 /* ntfn grp rep count */ +#define OCI_ATTR_AQ_NTFN_GROUPING_MSGID_ARRAY 236 /* aq grp msgid array */ +#define OCI_ATTR_AQ_NTFN_GROUPING_COUNT 237 /* ntfns recd in grp */ + +/* ----------------------- row callback attributes ------------------------- */ +#define OCI_ATTR_BIND_ROWCBK 301 /* bind row callback */ +#define OCI_ATTR_BIND_ROWCTX 302 /* ctx for bind row callback */ +#define OCI_ATTR_SKIP_BUFFER 303 /* skip buffer in array ops */ + +/* ----------------------- XStream API attributes -------------------------- */ +#define OCI_ATTR_XSTREAM_ACK_INTERVAL 350 /* XStream ack interval */ +#define OCI_ATTR_XSTREAM_IDLE_TIMEOUT 351 /* XStream idle timeout */ + +/*----- Db Change Notification (CQ) statement handle attributes------------ */ +#define OCI_ATTR_CQ_QUERYID 304 +/* ------------- DB Change Notification reg handle attributes ---------------*/ +#define OCI_ATTR_CHNF_TABLENAMES 401 /* out: array of table names */ +#define OCI_ATTR_CHNF_ROWIDS 402 /* in: rowids needed */ +#define OCI_ATTR_CHNF_OPERATIONS 403 + /* in: notification operation filter*/ +#define OCI_ATTR_CHNF_CHANGELAG 404 + /* txn lag between notifications */ + +/* DB Change: Notification Descriptor attributes -----------------------*/ +#define OCI_ATTR_CHDES_DBNAME 405 /* source database */ +#define OCI_ATTR_CHDES_NFYTYPE 406 /* notification type flags */ +#define OCI_ATTR_CHDES_XID 407 /* XID of the transaction */ +#define OCI_ATTR_CHDES_TABLE_CHANGES 408/* array of table chg descriptors*/ + +#define OCI_ATTR_CHDES_TABLE_NAME 409 /* table name */ +#define OCI_ATTR_CHDES_TABLE_OPFLAGS 410 /* table operation flags */ +#define OCI_ATTR_CHDES_TABLE_ROW_CHANGES 411 /* array of changed rows */ +#define OCI_ATTR_CHDES_ROW_ROWID 412 /* rowid of changed row */ +#define OCI_ATTR_CHDES_ROW_OPFLAGS 413 /* row operation flags */ + +/* Statement handle attribute for db change notification */ +#define OCI_ATTR_CHNF_REGHANDLE 414 /* IN: subscription handle */ +#define OCI_ATTR_NETWORK_FILE_DESC 415 /* network file descriptor */ + +/* client name for single session proxy */ +#define OCI_ATTR_PROXY_CLIENT 416 + +/* 415 is already taken - see OCI_ATTR_RESERVED_21 */ + +/* TDE attributes on the Table */ +#define OCI_ATTR_TABLE_ENC 417/* does table have any encrypt columns */ +#define OCI_ATTR_TABLE_ENC_ALG 418 /* Table encryption Algorithm */ +#define OCI_ATTR_TABLE_ENC_ALG_ID 419 /* Internal Id of encryption Algorithm*/ + +/* -------- Attributes related to Statement cache callback ----------------- */ +#define OCI_ATTR_STMTCACHE_CBKCTX 420 /* opaque context on stmt */ +#define OCI_ATTR_STMTCACHE_CBK 421 /* callback fn for stmtcache */ + +/*---------------- Query change descriptor attributes -----------------------*/ +#define OCI_ATTR_CQDES_OPERATION 422 +#define OCI_ATTR_CQDES_TABLE_CHANGES 423 +#define OCI_ATTR_CQDES_QUERYID 424 + + +#define OCI_ATTR_CHDES_QUERIES 425 /* Top level change desc array of queries */ + +/* Please use from 143 */ + +/* -------- Internal statement attributes ------- */ +#define OCI_ATTR_RESERVED_26 422 + +/* 424 is used by OCI_ATTR_DRIVER_NAME */ +/* --------- Attributes added to support server side session pool ---------- */ +#define OCI_ATTR_CONNECTION_CLASS 425 +#define OCI_ATTR_PURITY 426 + +#define OCI_ATTR_PURITY_DEFAULT 0x00 +#define OCI_ATTR_PURITY_NEW 0x01 +#define OCI_ATTR_PURITY_SELF 0x02 + +/* -------- Attributes for Times Ten --------------------------*/ +#define OCI_ATTR_RESERVED_28 426 /* reserved */ +#define OCI_ATTR_RESERVED_29 427 /* reserved */ +#define OCI_ATTR_RESERVED_30 428 /* reserved */ +#define OCI_ATTR_RESERVED_31 429 /* reserved */ +#define OCI_ATTR_RESERVED_32 430 /* reserved */ +#define OCI_ATTR_RESERVED_41 454 /* reserved */ + + +/* ----------- Reserve internal attributes for workload replay ------------ */ +#define OCI_ATTR_RESERVED_33 433 +#define OCI_ATTR_RESERVED_34 434 + +/* statement attribute */ +#define OCI_ATTR_RESERVED_36 444 + +/* -------- Attributes for Network Session Time Out--------------------------*/ +#define OCI_ATTR_SEND_TIMEOUT 435 /* NS send timeout */ +#define OCI_ATTR_RECEIVE_TIMEOUT 436 /* NS receive timeout */ + +/*--------- Attributes related to LOB prefetch------------------------------ */ +#define OCI_ATTR_DEFAULT_LOBPREFETCH_SIZE 438 /* default prefetch size */ +#define OCI_ATTR_LOBPREFETCH_SIZE 439 /* prefetch size */ +#define OCI_ATTR_LOBPREFETCH_LENGTH 440 /* prefetch length & chunk */ + +/*--------- Attributes related to LOB Deduplicate Regions ------------------ */ +#define OCI_ATTR_LOB_REGION_PRIMARY 442 /* Primary LOB Locator */ +#define OCI_ATTR_LOB_REGION_PRIMOFF 443 /* Offset into Primary LOB */ +#define OCI_ATTR_LOB_REGION_OFFSET 445 /* Region Offset */ +#define OCI_ATTR_LOB_REGION_LENGTH 446 /* Region Length Bytes/Chars */ +#define OCI_ATTR_LOB_REGION_MIME 447 /* Region mime type */ + +/*--------------------Attribute to fetch ROWID ------------------------------*/ +#define OCI_ATTR_FETCH_ROWID 448 + +/* server attribute */ +#define OCI_ATTR_RESERVED_37 449 + +/*------------------- Client Internal Attributes -----------------------*/ +#define OCI_ATTR_RESERVED_38 450 +#define OCI_ATTR_RESERVED_39 451 + +/* --------------- ip address attribute in environment handle -------------- */ +#define OCI_ATTR_SUBSCR_IPADDR 452 /* ip address to listen on */ + +/* server attribute */ +#define OCI_ATTR_RESERVED_40 453 + +/* DB Change: Event types ---------------*/ +#define OCI_EVENT_NONE 0x0 /* None */ +#define OCI_EVENT_STARTUP 0x1 /* Startup database */ +#define OCI_EVENT_SHUTDOWN 0x2 /* Shutdown database */ +#define OCI_EVENT_SHUTDOWN_ANY 0x3 /* Startup instance */ +#define OCI_EVENT_DROP_DB 0x4 /* Drop database */ +#define OCI_EVENT_DEREG 0x5 /* Subscription deregistered */ +#define OCI_EVENT_OBJCHANGE 0x6 /* Object change notification */ +#define OCI_EVENT_QUERYCHANGE 0x7 /* query result change */ + +/* DB Change: Operation types -----------*/ +#define OCI_OPCODE_ALLROWS 0x1 /* all rows invalidated */ +#define OCI_OPCODE_ALLOPS 0x0 /* interested in all operations */ +#define OCI_OPCODE_INSERT 0x2 /* INSERT */ +#define OCI_OPCODE_UPDATE 0x4 /* UPDATE */ +#define OCI_OPCODE_DELETE 0x8 /* DELETE */ +#define OCI_OPCODE_ALTER 0x10 /* ALTER */ +#define OCI_OPCODE_DROP 0x20 /* DROP TABLE */ +#define OCI_OPCODE_UNKNOWN 0x40 /* GENERIC/ UNKNOWN*/ + +/* -------- client side character and national character set ids ----------- */ +#define OCI_ATTR_ENV_CHARSET_ID OCI_ATTR_CHARSET_ID /* charset id in env */ +#define OCI_ATTR_ENV_NCHARSET_ID OCI_ATTR_NCHARSET_ID /* ncharset id in env */ + +/* ----------------------- ha event callback attributes -------------------- */ +#define OCI_ATTR_EVTCBK 304 /* ha callback */ +#define OCI_ATTR_EVTCTX 305 /* ctx for ha callback */ + +/* ------------------ User memory attributes (all handles) ----------------- */ +#define OCI_ATTR_USER_MEMORY 306 /* pointer to user memory */ + +/* ------- unauthorised access and user action auditing banners ------------ */ +#define OCI_ATTR_ACCESS_BANNER 307 /* access banner */ +#define OCI_ATTR_AUDIT_BANNER 308 /* audit banner */ + +/* ----------------- port no attribute in environment handle ------------- */ +#define OCI_ATTR_SUBSCR_PORTNO 390 /* port no to listen */ + +#define OCI_ATTR_RESERVED_35 437 + +/*------------- Supported Values for protocol for recepient -----------------*/ +#define OCI_SUBSCR_PROTO_OCI 0 /* oci */ +#define OCI_SUBSCR_PROTO_MAIL 1 /* mail */ +#define OCI_SUBSCR_PROTO_SERVER 2 /* server */ +#define OCI_SUBSCR_PROTO_HTTP 3 /* http */ +#define OCI_SUBSCR_PROTO_MAX 4 /* max current protocols */ + +/*------------- Supported Values for presentation for recepient -------------*/ +#define OCI_SUBSCR_PRES_DEFAULT 0 /* default */ +#define OCI_SUBSCR_PRES_XML 1 /* xml */ +#define OCI_SUBSCR_PRES_MAX 2 /* max current presentations */ + +/*------------- Supported QOS values for notification registrations ---------*/ +#define OCI_SUBSCR_QOS_RELIABLE 0x01 /* reliable */ +#define OCI_SUBSCR_QOS_PAYLOAD 0x02 /* payload delivery */ +#define OCI_SUBSCR_QOS_REPLICATE 0x04 /* replicate to director */ +#define OCI_SUBSCR_QOS_SECURE 0x08 /* secure payload delivery */ +#define OCI_SUBSCR_QOS_PURGE_ON_NTFN 0x10 /* purge on first ntfn */ +#define OCI_SUBSCR_QOS_MULTICBK 0x20 /* multi instance callback */ + /* 0x40 is used for a internal flag */ +#define OCI_SUBSCR_QOS_HAREG 0x80 /* HA reg */ + +/* ----QOS flags specific to change notification/ continuous queries CQ -----*/ +#define OCI_SUBSCR_CQ_QOS_QUERY 0x01 /* query level notification */ +#define OCI_SUBSCR_CQ_QOS_BEST_EFFORT 0x02 /* best effort notification */ +#define OCI_SUBSCR_CQ_QOS_CLQRYCACHE 0x04 /* client query caching */ + +/*------------- Supported Values for notification grouping class ------------*/ +#define OCI_SUBSCR_NTFN_GROUPING_CLASS_TIME 1 /* time */ + +/*------------- Supported Values for notification grouping type -------------*/ +#define OCI_SUBSCR_NTFN_GROUPING_TYPE_SUMMARY 1 /* summary */ +#define OCI_SUBSCR_NTFN_GROUPING_TYPE_LAST 2 /* last */ + +/* ----- Temporary attribute value for UCS2/UTF16 character set ID -------- */ +#define OCI_UCS2ID 1000 /* UCS2 charset ID */ +#define OCI_UTF16ID 1000 /* UTF16 charset ID */ + +/*============================== End OCI Attribute Types ====================*/ + +/*---------------- Server Handle Attribute Values ---------------------------*/ + +/* OCI_ATTR_SERVER_STATUS */ +#define OCI_SERVER_NOT_CONNECTED 0x0 +#define OCI_SERVER_NORMAL 0x1 + +/*---------------------------------------------------------------------------*/ + +/*------------------------- Supported Namespaces ---------------------------*/ +#define OCI_SUBSCR_NAMESPACE_ANONYMOUS 0 /* Anonymous Namespace */ +#define OCI_SUBSCR_NAMESPACE_AQ 1 /* Advanced Queues */ +#define OCI_SUBSCR_NAMESPACE_DBCHANGE 2 /* change notification */ +#define OCI_SUBSCR_NAMESPACE_MAX 3 /* Max Name Space Number */ + + +/*-------------------------Credential Types----------------------------------*/ +#define OCI_CRED_RDBMS 1 /* database username/password */ +#define OCI_CRED_EXT 2 /* externally provided credentials */ +#define OCI_CRED_PROXY 3 /* proxy authentication */ +#define OCI_CRED_RESERVED_1 4 /* reserved */ +#define OCI_CRED_RESERVED_2 5 /* reserved */ +/*---------------------------------------------------------------------------*/ + +/*------------------------Error Return Values--------------------------------*/ +#define OCI_SUCCESS 0 /* maps to SQL_SUCCESS of SAG CLI */ +#define OCI_SUCCESS_WITH_INFO 1 /* maps to SQL_SUCCESS_WITH_INFO */ +#define OCI_RESERVED_FOR_INT_USE 200 /* reserved */ +#define OCI_NO_DATA 100 /* maps to SQL_NO_DATA */ +#define OCI_ERROR -1 /* maps to SQL_ERROR */ +#define OCI_INVALID_HANDLE -2 /* maps to SQL_INVALID_HANDLE */ +#define OCI_NEED_DATA 99 /* maps to SQL_NEED_DATA */ +#define OCI_STILL_EXECUTING -3123 /* OCI would block error */ +/*---------------------------------------------------------------------------*/ + +/*--------------------- User Callback Return Values -------------------------*/ +#define OCI_CONTINUE -24200 /* Continue with the body of the OCI function */ +#define OCI_ROWCBK_DONE -24201 /* done with user row callback */ +/*---------------------------------------------------------------------------*/ + +/*------------------DateTime and Interval check Error codes------------------*/ + +/* DateTime Error Codes used by OCIDateTimeCheck() */ +#define OCI_DT_INVALID_DAY 0x1 /* Bad day */ +#define OCI_DT_DAY_BELOW_VALID 0x2 /* Bad DAy Low/high bit (1=low)*/ +#define OCI_DT_INVALID_MONTH 0x4 /* Bad MOnth */ +#define OCI_DT_MONTH_BELOW_VALID 0x8 /* Bad MOnth Low/high bit (1=low) */ +#define OCI_DT_INVALID_YEAR 0x10 /* Bad YeaR */ +#define OCI_DT_YEAR_BELOW_VALID 0x20 /* Bad YeaR Low/high bit (1=low) */ +#define OCI_DT_INVALID_HOUR 0x40 /* Bad HouR */ +#define OCI_DT_HOUR_BELOW_VALID 0x80 /* Bad HouR Low/high bit (1=low) */ +#define OCI_DT_INVALID_MINUTE 0x100 /* Bad MiNute */ +#define OCI_DT_MINUTE_BELOW_VALID 0x200 /*Bad MiNute Low/high bit (1=low) */ +#define OCI_DT_INVALID_SECOND 0x400 /* Bad SeCond */ +#define OCI_DT_SECOND_BELOW_VALID 0x800 /*bad second Low/high bit (1=low)*/ +#define OCI_DT_DAY_MISSING_FROM_1582 0x1000 + /* Day is one of those "missing" from 1582 */ +#define OCI_DT_YEAR_ZERO 0x2000 /* Year may not equal zero */ +#define OCI_DT_INVALID_TIMEZONE 0x4000 /* Bad Timezone */ +#define OCI_DT_INVALID_FORMAT 0x8000 /* Bad date format input */ + + +/* Interval Error Codes used by OCIInterCheck() */ +#define OCI_INTER_INVALID_DAY 0x1 /* Bad day */ +#define OCI_INTER_DAY_BELOW_VALID 0x2 /* Bad DAy Low/high bit (1=low) */ +#define OCI_INTER_INVALID_MONTH 0x4 /* Bad MOnth */ +#define OCI_INTER_MONTH_BELOW_VALID 0x8 /*Bad MOnth Low/high bit (1=low) */ +#define OCI_INTER_INVALID_YEAR 0x10 /* Bad YeaR */ +#define OCI_INTER_YEAR_BELOW_VALID 0x20 /*Bad YeaR Low/high bit (1=low) */ +#define OCI_INTER_INVALID_HOUR 0x40 /* Bad HouR */ +#define OCI_INTER_HOUR_BELOW_VALID 0x80 /*Bad HouR Low/high bit (1=low) */ +#define OCI_INTER_INVALID_MINUTE 0x100 /* Bad MiNute */ +#define OCI_INTER_MINUTE_BELOW_VALID 0x200 + /*Bad MiNute Low/high bit(1=low) */ +#define OCI_INTER_INVALID_SECOND 0x400 /* Bad SeCond */ +#define OCI_INTER_SECOND_BELOW_VALID 0x800 + /*bad second Low/high bit(1=low) */ +#define OCI_INTER_INVALID_FRACSEC 0x1000 /* Bad Fractional second */ +#define OCI_INTER_FRACSEC_BELOW_VALID 0x2000 + /* Bad fractional second Low/High */ + + +/*------------------------Parsing Syntax Types-------------------------------*/ +#define OCI_V7_SYNTAX 2 /* V815 language - for backwards compatibility */ +#define OCI_V8_SYNTAX 3 /* V815 language - for backwards compatibility */ +#define OCI_NTV_SYNTAX 1 /* Use what so ever is the native lang of server */ + /* these values must match the values defined in kpul.h */ +/*---------------------------------------------------------------------------*/ + +/*------------------------(Scrollable Cursor) Fetch Options------------------- + * For non-scrollable cursor, the only valid (and default) orientation is + * OCI_FETCH_NEXT + */ +#define OCI_FETCH_CURRENT 0x00000001 /* refetching current position */ +#define OCI_FETCH_NEXT 0x00000002 /* next row */ +#define OCI_FETCH_FIRST 0x00000004 /* first row of the result set */ +#define OCI_FETCH_LAST 0x00000008 /* the last row of the result set */ +#define OCI_FETCH_PRIOR 0x00000010 /* previous row relative to current */ +#define OCI_FETCH_ABSOLUTE 0x00000020 /* absolute offset from first */ +#define OCI_FETCH_RELATIVE 0x00000040 /* offset relative to current */ +#define OCI_FETCH_RESERVED_1 0x00000080 /* reserved */ +#define OCI_FETCH_RESERVED_2 0x00000100 /* reserved */ +#define OCI_FETCH_RESERVED_3 0x00000200 /* reserved */ +#define OCI_FETCH_RESERVED_4 0x00000400 /* reserved */ +#define OCI_FETCH_RESERVED_5 0x00000800 /* reserved */ + +/*---------------------------------------------------------------------------*/ + +/*------------------------Bind and Define Options----------------------------*/ +#define OCI_SB2_IND_PTR 0x00000001 /* unused */ +#define OCI_DATA_AT_EXEC 0x00000002 /* data at execute time */ +#define OCI_DYNAMIC_FETCH 0x00000002 /* fetch dynamically */ +#define OCI_PIECEWISE 0x00000004 /* piecewise DMLs or fetch */ +#define OCI_DEFINE_RESERVED_1 0x00000008 /* reserved */ +#define OCI_BIND_RESERVED_2 0x00000010 /* reserved */ +#define OCI_DEFINE_RESERVED_2 0x00000020 /* reserved */ +#define OCI_BIND_SOFT 0x00000040 /* soft bind or define */ +#define OCI_DEFINE_SOFT 0x00000080 /* soft bind or define */ +#define OCI_BIND_RESERVED_3 0x00000100 /* reserved */ +#define OCI_IOV 0x00000200 /* For scatter gather bind/define */ +/*---------------------------------------------------------------------------*/ + +/*----------------------------- Various Modes ------------------------------*/ +#define OCI_DEFAULT 0x00000000 + /* the default value for parameters and attributes */ +/*-------------OCIInitialize Modes / OCICreateEnvironment Modes -------------*/ +#define OCI_THREADED 0x00000001 /* appl. in threaded environment */ +#define OCI_OBJECT 0x00000002 /* application in object environment */ +#define OCI_EVENTS 0x00000004 /* application is enabled for events */ +#define OCI_RESERVED1 0x00000008 /* reserved */ +#define OCI_SHARED 0x00000010 /* the application is in shared mode */ +#define OCI_RESERVED2 0x00000020 /* reserved */ +/* The following *TWO* are only valid for OCICreateEnvironment call */ +#define OCI_NO_UCB 0x00000040 /* No user callback called during ini */ +#define OCI_NO_MUTEX 0x00000080 /* the environment handle will not be */ + /* protected by a mutex internally */ +#define OCI_SHARED_EXT 0x00000100 /* Used for shared forms */ +/************************** 0x00000200 free **********************************/ +#define OCI_ALWAYS_BLOCKING 0x00000400 /* all connections always blocking */ +/************************** 0x00000800 free **********************************/ +#define OCI_USE_LDAP 0x00001000 /* allow LDAP connections */ +#define OCI_REG_LDAPONLY 0x00002000 /* only register to LDAP */ +#define OCI_UTF16 0x00004000 /* mode for all UTF16 metadata */ +#define OCI_AFC_PAD_ON 0x00008000 + /* turn on AFC blank padding when rlenp present */ +#define OCI_ENVCR_RESERVED3 0x00010000 /* reserved */ +#define OCI_NEW_LENGTH_SEMANTICS 0x00020000 /* adopt new length semantics */ + /* the new length semantics, always bytes, is used by OCIEnvNlsCreate */ +#define OCI_NO_MUTEX_STMT 0x00040000 /* Do not mutex stmt handle */ +#define OCI_MUTEX_ENV_ONLY 0x00080000 /* Mutex only the environment handle */ +#define OCI_SUPPRESS_NLS_VALIDATION 0x00100000 /* suppress nls validation */ + /* nls validation suppression is on by default; + use OCI_ENABLE_NLS_VALIDATION to disable it */ +#define OCI_MUTEX_TRY 0x00200000 /* try and acquire mutex */ +#define OCI_NCHAR_LITERAL_REPLACE_ON 0x00400000 /* nchar literal replace on */ +#define OCI_NCHAR_LITERAL_REPLACE_OFF 0x00800000 /* nchar literal replace off*/ +#define OCI_ENABLE_NLS_VALIDATION 0x01000000 /* enable nls validation */ +#define OCI_ENVCR_RESERVED4 0x02000000 /* reserved */ + +/*---------------------------------------------------------------------------*/ +/*------------------------OCIConnectionpoolCreate Modes----------------------*/ + +#define OCI_CPOOL_REINITIALIZE 0x111 + +/*---------------------------------------------------------------------------*/ +/*--------------------------------- OCILogon2 Modes -------------------------*/ + +#define OCI_LOGON2_SPOOL 0x0001 /* Use session pool */ +#define OCI_LOGON2_CPOOL OCI_CPOOL /* Use connection pool */ +#define OCI_LOGON2_STMTCACHE 0x0004 /* Use Stmt Caching */ +#define OCI_LOGON2_PROXY 0x0008 /* Proxy authentiaction */ + +/*---------------------------------------------------------------------------*/ +/*------------------------- OCISessionPoolCreate Modes ----------------------*/ + +#define OCI_SPC_REINITIALIZE 0x0001 /* Reinitialize the session pool */ +#define OCI_SPC_HOMOGENEOUS 0x0002 /* Session pool is homogeneneous */ +#define OCI_SPC_STMTCACHE 0x0004 /* Session pool has stmt cache */ +#define OCI_SPC_NO_RLB 0x0008 /* Do not enable Runtime load balancing. */ + +/*---------------------------------------------------------------------------*/ +/*--------------------------- OCISessionGet Modes ---------------------------*/ + +#define OCI_SESSGET_SPOOL 0x0001 /* SessionGet called in SPOOL mode */ +#define OCI_SESSGET_CPOOL OCI_CPOOL /* SessionGet called in CPOOL mode */ +#define OCI_SESSGET_STMTCACHE 0x0004 /* Use statement cache */ +#define OCI_SESSGET_CREDPROXY 0x0008 /* SessionGet called in proxy mode */ +#define OCI_SESSGET_CREDEXT 0x0010 +#define OCI_SESSGET_SPOOL_MATCHANY 0x0020 +#define OCI_SESSGET_PURITY_NEW 0x0040 +#define OCI_SESSGET_PURITY_SELF 0x0080 +#define OCI_SESSGET_SYSDBA 0x0100 /* SessionGet with SYSDBA privileges */ + +/*---------------------------------------------------------------------------*/ +/*------------------------ATTR Values for Session Pool-----------------------*/ +/* Attribute values for OCI_ATTR_SPOOL_GETMODE */ +#define OCI_SPOOL_ATTRVAL_WAIT 0 /* block till you get a session */ +#define OCI_SPOOL_ATTRVAL_NOWAIT 1 /* error out if no session avaliable */ +#define OCI_SPOOL_ATTRVAL_FORCEGET 2 /* get session even if max is exceeded */ + +/*---------------------------------------------------------------------------*/ +/*--------------------------- OCISessionRelease Modes -----------------------*/ + +#define OCI_SESSRLS_DROPSESS 0x0001 /* Drop the Session */ +#define OCI_SESSRLS_RETAG 0x0002 /* Retag the session */ + +/*---------------------------------------------------------------------------*/ +/*----------------------- OCISessionPoolDestroy Modes -----------------------*/ + +#define OCI_SPD_FORCE 0x0001 /* Force the sessions to terminate. + Even if there are some busy + sessions close them */ + +/*---------------------------------------------------------------------------*/ +/*----------------------------- Statement States ----------------------------*/ + +#define OCI_STMT_STATE_INITIALIZED 0x0001 +#define OCI_STMT_STATE_EXECUTED 0x0002 +#define OCI_STMT_STATE_END_OF_FETCH 0x0003 + +/*---------------------------------------------------------------------------*/ + +/*----------------------------- OCIMemStats Modes ---------------------------*/ +#define OCI_MEM_INIT 0x01 +#define OCI_MEM_CLN 0x02 +#define OCI_MEM_FLUSH 0x04 +#define OCI_DUMP_HEAP 0x80 + +#define OCI_CLIENT_STATS 0x10 +#define OCI_SERVER_STATS 0x20 + +/*----------------------------- OCIEnvInit Modes ----------------------------*/ +/* NOTE: NO NEW MODES SHOULD BE ADDED HERE BECAUSE THE RECOMMENDED METHOD + * IS TO USE THE NEW OCICreateEnvironment MODES. + */ +#define OCI_ENV_NO_UCB 0x01 /* A user callback will not be called in + OCIEnvInit() */ +#define OCI_ENV_NO_MUTEX 0x08 /* the environment handle will not be protected + by a mutex internally */ + +/*---------------------------------------------------------------------------*/ + +/*------------------------ Prepare Modes ------------------------------------*/ +#define OCI_NO_SHARING 0x01 /* turn off statement handle sharing */ +#define OCI_PREP_RESERVED_1 0x02 /* reserved */ +#define OCI_PREP_AFC_PAD_ON 0x04 /* turn on blank padding for AFC */ +#define OCI_PREP_AFC_PAD_OFF 0x08 /* turn off blank padding for AFC */ +/*---------------------------------------------------------------------------*/ + +/*---------------------------------------------------------------------------*/ + +/*----------------------- Execution Modes -----------------------------------*/ +#define OCI_BATCH_MODE 0x00000001 /* batch the oci stmt for exec */ +#define OCI_EXACT_FETCH 0x00000002 /* fetch exact rows specified */ +/* #define 0x00000004 available */ +#define OCI_STMT_SCROLLABLE_READONLY \ + 0x00000008 /* if result set is scrollable */ +#define OCI_DESCRIBE_ONLY 0x00000010 /* only describe the statement */ +#define OCI_COMMIT_ON_SUCCESS 0x00000020 /* commit, if successful exec */ +#define OCI_NON_BLOCKING 0x00000040 /* non-blocking */ +#define OCI_BATCH_ERRORS 0x00000080 /* batch errors in array dmls */ +#define OCI_PARSE_ONLY 0x00000100 /* only parse the statement */ +#define OCI_EXACT_FETCH_RESERVED_1 0x00000200 /* reserved */ +#define OCI_SHOW_DML_WARNINGS 0x00000400 + /* return OCI_SUCCESS_WITH_INFO for delete/update w/no where clause */ +#define OCI_EXEC_RESERVED_2 0x00000800 /* reserved */ +#define OCI_DESC_RESERVED_1 0x00001000 /* reserved */ +#define OCI_EXEC_RESERVED_3 0x00002000 /* reserved */ +#define OCI_EXEC_RESERVED_4 0x00004000 /* reserved */ +#define OCI_EXEC_RESERVED_5 0x00008000 /* reserved */ +#define OCI_EXEC_RESERVED_6 0x00010000 /* reserved */ +#define OCI_RESULT_CACHE 0x00020000 /* hint to use query caching */ +#define OCI_NO_RESULT_CACHE 0x00040000 /*hint to bypass query caching*/ +#define OCI_EXEC_RESERVED_7 0x00080000 /* reserved */ + +/*---------------------------------------------------------------------------*/ + +/*------------------------Authentication Modes-------------------------------*/ +#define OCI_MIGRATE 0x00000001 /* migratable auth context */ +#define OCI_SYSDBA 0x00000002 /* for SYSDBA authorization */ +#define OCI_SYSOPER 0x00000004 /* for SYSOPER authorization */ +#define OCI_PRELIM_AUTH 0x00000008 /* for preliminary authorization */ +#define OCIP_ICACHE 0x00000010 /* Private OCI cache mode */ +#define OCI_AUTH_RESERVED_1 0x00000020 /* reserved */ +#define OCI_STMT_CACHE 0x00000040 /* enable OCI Stmt Caching */ +#define OCI_STATELESS_CALL 0x00000080 /* stateless at call boundary */ +#define OCI_STATELESS_TXN 0x00000100 /* stateless at txn boundary */ +#define OCI_STATELESS_APP 0x00000200 /* stateless at user-specified pts */ +#define OCI_AUTH_RESERVED_2 0x00000400 /* reserved */ +#define OCI_AUTH_RESERVED_3 0x00000800 /* reserved */ +#define OCI_AUTH_RESERVED_4 0x00001000 /* reserved */ +#define OCI_AUTH_RESERVED_5 0x00002000 /* reserved */ +#define OCI_SYSASM 0x00008000 /* for SYSASM authorization */ +#define OCI_AUTH_RESERVED_6 0x00010000 /* reserved */ + +/*---------------------------------------------------------------------------*/ + +/*------------------------Session End Modes----------------------------------*/ +#define OCI_SESSEND_RESERVED_1 0x0001 /* reserved */ +#define OCI_SESSEND_RESERVED_2 0x0002 /* reserved */ +/*---------------------------------------------------------------------------*/ + +/*------------------------Attach Modes---------------------------------------*/ + +/* The following attach modes are the same as the UPI modes defined in + * UPIDEF.H. Do not use these values externally. + */ + +#define OCI_FASTPATH 0x0010 /* Attach in fast path mode */ +#define OCI_ATCH_RESERVED_1 0x0020 /* reserved */ +#define OCI_ATCH_RESERVED_2 0x0080 /* reserved */ +#define OCI_ATCH_RESERVED_3 0x0100 /* reserved */ +#define OCI_CPOOL 0x0200 /* Attach using server handle from pool */ +#define OCI_ATCH_RESERVED_4 0x0400 /* reserved */ +#define OCI_ATCH_RESERVED_5 0x2000 /* reserved */ +#define OCI_ATCH_ENABLE_BEQ 0x4000 /* Allow bequeath connect strings */ +#define OCI_ATCH_RESERVED_6 0x8000 /* reserved */ +#define OCI_ATCH_RESERVED_7 0x10000 /* reserved */ +#define OCI_ATCH_RESERVED_8 0x20000 /* reserved */ + +#define OCI_SRVATCH_RESERVED5 0x01000000 /* reserved */ +#define OCI_SRVATCH_RESERVED6 0x02000000 /* reserved */ + +/*---------------------OCIStmtPrepare2 Modes---------------------------------*/ +#define OCI_PREP2_CACHE_SEARCHONLY 0x0010 /* ONly Search */ +#define OCI_PREP2_GET_PLSQL_WARNINGS 0x0020 /* Get PL/SQL warnings */ +#define OCI_PREP2_RESERVED_1 0x0040 /* reserved */ + +/*---------------------OCIStmtRelease Modes----------------------------------*/ +#define OCI_STRLS_CACHE_DELETE 0x0010 /* Delete from Cache */ + +/*---------------------OCIHanlde Mgmt Misc Modes-----------------------------*/ +#define OCI_STM_RESERVED4 0x00100000 /* reserved */ + +/*-----------------------------End Various Modes ----------------------------*/ + +/*------------------------Piece Information----------------------------------*/ +#define OCI_PARAM_IN 0x01 /* in parameter */ +#define OCI_PARAM_OUT 0x02 /* out parameter */ +/*---------------------------------------------------------------------------*/ + +/*------------------------ Transaction Start Flags --------------------------*/ +/* NOTE: OCI_TRANS_JOIN and OCI_TRANS_NOMIGRATE not supported in 8.0.X */ +#define OCI_TRANS_NEW 0x00000001 /* start a new local or global txn */ +#define OCI_TRANS_JOIN 0x00000002 /* join an existing global txn */ +#define OCI_TRANS_RESUME 0x00000004 /* resume the global txn branch */ +#define OCI_TRANS_PROMOTE 0x00000008 /* promote the local txn to global */ +#define OCI_TRANS_STARTMASK 0x000000ff /* mask for start operation flags */ + +#define OCI_TRANS_READONLY 0x00000100 /* start a readonly txn */ +#define OCI_TRANS_READWRITE 0x00000200 /* start a read-write txn */ +#define OCI_TRANS_SERIALIZABLE 0x00000400 /* start a serializable txn */ +#define OCI_TRANS_ISOLMASK 0x0000ff00 /* mask for start isolation flags */ + +#define OCI_TRANS_LOOSE 0x00010000 /* a loosely coupled branch */ +#define OCI_TRANS_TIGHT 0x00020000 /* a tightly coupled branch */ +#define OCI_TRANS_TYPEMASK 0x000f0000 /* mask for branch type flags */ + +#define OCI_TRANS_NOMIGRATE 0x00100000 /* non migratable transaction */ +#define OCI_TRANS_SEPARABLE 0x00200000 /* separable transaction (8.1.6+) */ +#define OCI_TRANS_OTSRESUME 0x00400000 /* OTS resuming a transaction */ +#define OCI_TRANS_OTHRMASK 0xfff00000 /* mask for other start flags */ + + +/*---------------------------------------------------------------------------*/ + +/*------------------------ Transaction End Flags ----------------------------*/ +#define OCI_TRANS_TWOPHASE 0x01000000 /* use two phase commit */ +#define OCI_TRANS_WRITEBATCH 0x00000001 /* force cmt-redo for local txns */ +#define OCI_TRANS_WRITEIMMED 0x00000002 /* no force cmt-redo */ +#define OCI_TRANS_WRITEWAIT 0x00000004 /* no sync cmt-redo */ +#define OCI_TRANS_WRITENOWAIT 0x00000008 /* sync cmt-redo for local txns */ +/*---------------------------------------------------------------------------*/ + +/*------------------------- AQ Constants ------------------------------------ + * NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE + * The following constants must match the PL/SQL dbms_aq constants + * NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE + */ +/* ------------------------- Visibility flags -------------------------------*/ +#define OCI_ENQ_IMMEDIATE 1 /* enqueue is an independent transaction */ +#define OCI_ENQ_ON_COMMIT 2 /* enqueue is part of current transaction */ + +/* ----------------------- Dequeue mode flags -------------------------------*/ +#define OCI_DEQ_BROWSE 1 /* read message without acquiring a lock */ +#define OCI_DEQ_LOCKED 2 /* read and obtain write lock on message */ +#define OCI_DEQ_REMOVE 3 /* read the message and delete it */ +#define OCI_DEQ_REMOVE_NODATA 4 /* delete message w'o returning payload */ +#define OCI_DEQ_GETSIG 5 /* get signature only */ + +/* ----------------- Dequeue navigation flags -------------------------------*/ +#define OCI_DEQ_FIRST_MSG 1 /* get first message at head of queue */ +#define OCI_DEQ_NEXT_MSG 3 /* next message that is available */ +#define OCI_DEQ_NEXT_TRANSACTION 2 /* get first message of next txn group */ +#define OCI_DEQ_FIRST_MSG_MULTI_GROUP 4 + /* start from first message and array deq across txn groups */ +#define OCI_DEQ_MULT_TRANSACTION 5 /* array dequeue across txn groups */ +#define OCI_DEQ_NEXT_MSG_MULTI_GROUP OCI_DEQ_MULT_TRANSACTION + /* array dequeue across txn groups */ + +/* ----------------- Dequeue Option Reserved flags ------------------------- */ +#define OCI_DEQ_RESERVED_1 0x000001 + +/* --------------------- Message states -------------------------------------*/ +#define OCI_MSG_WAITING 1 /* the message delay has not yet completed */ +#define OCI_MSG_READY 0 /* the message is ready to be processed */ +#define OCI_MSG_PROCESSED 2 /* the message has been processed */ +#define OCI_MSG_EXPIRED 3 /* message has moved to exception queue */ + +/* --------------------- Sequence deviation ---------------------------------*/ +#define OCI_ENQ_BEFORE 2 /* enqueue message before another message */ +#define OCI_ENQ_TOP 3 /* enqueue message before all messages */ + +/* ------------------------- Visibility flags -------------------------------*/ +#define OCI_DEQ_IMMEDIATE 1 /* dequeue is an independent transaction */ +#define OCI_DEQ_ON_COMMIT 2 /* dequeue is part of current transaction */ + +/* ------------------------ Wait --------------------------------------------*/ +#define OCI_DEQ_WAIT_FOREVER -1 /* wait forever if no message available */ +#define OCI_NTFN_GROUPING_FOREVER -1 /* send grouping notifications forever */ +#define OCI_DEQ_NO_WAIT 0 /* do not wait if no message is available */ + +#define OCI_FLOW_CONTROL_NO_TIMEOUT -1 + /* streaming enqueue: no timeout for flow control */ + +/* ------------------------ Delay -------------------------------------------*/ +#define OCI_MSG_NO_DELAY 0 /* message is available immediately */ + +/* ------------------------- Expiration -------------------------------------*/ +#define OCI_MSG_NO_EXPIRATION -1 /* message will never expire */ + +#define OCI_MSG_PERSISTENT_OR_BUFFERED 3 +#define OCI_MSG_BUFFERED 2 +#define OCI_MSG_PERSISTENT 1 + +/* ----------------------- Reserved/AQE pisdef flags ------------------------*/ +/* see aqeflg defines in kwqp.h */ +#define OCI_AQ_RESERVED_1 0x0002 +#define OCI_AQ_RESERVED_2 0x0004 +#define OCI_AQ_RESERVED_3 0x0008 +#define OCI_AQ_RESERVED_4 0x0010 + +#define OCI_AQ_STREAMING_FLAG 0x02000000 + +/* ------------------------------ Replay Info -------------------------------*/ +#define OCI_AQ_LAST_ENQUEUED 0 +#define OCI_AQ_LAST_ACKNOWLEDGED 1 + +/* -------------------------- END AQ Constants ----------------------------- */ + +/* --------------------END DateTime and Interval Constants ------------------*/ + +/*-----------------------Object Types----------------------------------------*/ +/*-----------Object Types **** Not to be Used **** --------------------------*/ +/* Deprecated */ +#define OCI_OTYPE_UNK 0 +#define OCI_OTYPE_TABLE 1 +#define OCI_OTYPE_VIEW 2 +#define OCI_OTYPE_SYN 3 +#define OCI_OTYPE_PROC 4 +#define OCI_OTYPE_FUNC 5 +#define OCI_OTYPE_PKG 6 +#define OCI_OTYPE_STMT 7 +/*---------------------------------------------------------------------------*/ + +/*=======================Describe Handle Parameter Attributes ===============*/ +/* + These attributes are orthogonal to the other set of attributes defined + above. These attrubutes are to be used only for the describe handle. +*/ +/*===========================================================================*/ +/* Attributes common to Columns and Stored Procs */ +#define OCI_ATTR_DATA_SIZE 1 /* maximum size of the data */ +#define OCI_ATTR_DATA_TYPE 2 /* the SQL type of the column/argument */ +#define OCI_ATTR_DISP_SIZE 3 /* the display size */ +#define OCI_ATTR_NAME 4 /* the name of the column/argument */ +#define OCI_ATTR_PRECISION 5 /* precision if number type */ +#define OCI_ATTR_SCALE 6 /* scale if number type */ +#define OCI_ATTR_IS_NULL 7 /* is it null ? */ +#define OCI_ATTR_TYPE_NAME 8 + /* name of the named data type or a package name for package private types */ +#define OCI_ATTR_SCHEMA_NAME 9 /* the schema name */ +#define OCI_ATTR_SUB_NAME 10 /* type name if package private type */ +#define OCI_ATTR_POSITION 11 + /* relative position of col/arg in the list of cols/args */ +/* complex object retrieval parameter attributes */ +#define OCI_ATTR_COMPLEXOBJECTCOMP_TYPE 50 +#define OCI_ATTR_COMPLEXOBJECTCOMP_TYPE_LEVEL 51 +#define OCI_ATTR_COMPLEXOBJECT_LEVEL 52 +#define OCI_ATTR_COMPLEXOBJECT_COLL_OUTOFLINE 53 + +/* Only Columns */ +#define OCI_ATTR_DISP_NAME 100 /* the display name */ +#define OCI_ATTR_ENCC_SIZE 101 /* encrypted data size */ +#define OCI_ATTR_COL_ENC 102 /* column is encrypted ? */ +#define OCI_ATTR_COL_ENC_SALT 103 /* is encrypted column salted ? */ + +/*Only Stored Procs */ +#define OCI_ATTR_OVERLOAD 210 /* is this position overloaded */ +#define OCI_ATTR_LEVEL 211 /* level for structured types */ +#define OCI_ATTR_HAS_DEFAULT 212 /* has a default value */ +#define OCI_ATTR_IOMODE 213 /* in, out inout */ +#define OCI_ATTR_RADIX 214 /* returns a radix */ +#define OCI_ATTR_NUM_ARGS 215 /* total number of arguments */ + +/* only named type attributes */ +#define OCI_ATTR_TYPECODE 216 /* object or collection */ +#define OCI_ATTR_COLLECTION_TYPECODE 217 /* varray or nested table */ +#define OCI_ATTR_VERSION 218 /* user assigned version */ +#define OCI_ATTR_IS_INCOMPLETE_TYPE 219 /* is this an incomplete type */ +#define OCI_ATTR_IS_SYSTEM_TYPE 220 /* a system type */ +#define OCI_ATTR_IS_PREDEFINED_TYPE 221 /* a predefined type */ +#define OCI_ATTR_IS_TRANSIENT_TYPE 222 /* a transient type */ +#define OCI_ATTR_IS_SYSTEM_GENERATED_TYPE 223 /* system generated type */ +#define OCI_ATTR_HAS_NESTED_TABLE 224 /* contains nested table attr */ +#define OCI_ATTR_HAS_LOB 225 /* has a lob attribute */ +#define OCI_ATTR_HAS_FILE 226 /* has a file attribute */ +#define OCI_ATTR_COLLECTION_ELEMENT 227 /* has a collection attribute */ +#define OCI_ATTR_NUM_TYPE_ATTRS 228 /* number of attribute types */ +#define OCI_ATTR_LIST_TYPE_ATTRS 229 /* list of type attributes */ +#define OCI_ATTR_NUM_TYPE_METHODS 230 /* number of type methods */ +#define OCI_ATTR_LIST_TYPE_METHODS 231 /* list of type methods */ +#define OCI_ATTR_MAP_METHOD 232 /* map method of type */ +#define OCI_ATTR_ORDER_METHOD 233 /* order method of type */ + +/* only collection element */ +#define OCI_ATTR_NUM_ELEMS 234 /* number of elements */ + +/* only type methods */ +#define OCI_ATTR_ENCAPSULATION 235 /* encapsulation level */ +#define OCI_ATTR_IS_SELFISH 236 /* method selfish */ +#define OCI_ATTR_IS_VIRTUAL 237 /* virtual */ +#define OCI_ATTR_IS_INLINE 238 /* inline */ +#define OCI_ATTR_IS_CONSTANT 239 /* constant */ +#define OCI_ATTR_HAS_RESULT 240 /* has result */ +#define OCI_ATTR_IS_CONSTRUCTOR 241 /* constructor */ +#define OCI_ATTR_IS_DESTRUCTOR 242 /* destructor */ +#define OCI_ATTR_IS_OPERATOR 243 /* operator */ +#define OCI_ATTR_IS_MAP 244 /* a map method */ +#define OCI_ATTR_IS_ORDER 245 /* order method */ +#define OCI_ATTR_IS_RNDS 246 /* read no data state method */ +#define OCI_ATTR_IS_RNPS 247 /* read no process state */ +#define OCI_ATTR_IS_WNDS 248 /* write no data state method */ +#define OCI_ATTR_IS_WNPS 249 /* write no process state */ + +#define OCI_ATTR_DESC_PUBLIC 250 /* public object */ + +/* Object Cache Enhancements : attributes for User Constructed Instances */ +#define OCI_ATTR_CACHE_CLIENT_CONTEXT 251 +#define OCI_ATTR_UCI_CONSTRUCT 252 +#define OCI_ATTR_UCI_DESTRUCT 253 +#define OCI_ATTR_UCI_COPY 254 +#define OCI_ATTR_UCI_PICKLE 255 +#define OCI_ATTR_UCI_UNPICKLE 256 +#define OCI_ATTR_UCI_REFRESH 257 + +/* for type inheritance */ +#define OCI_ATTR_IS_SUBTYPE 258 +#define OCI_ATTR_SUPERTYPE_SCHEMA_NAME 259 +#define OCI_ATTR_SUPERTYPE_NAME 260 + +/* for schemas */ +#define OCI_ATTR_LIST_OBJECTS 261 /* list of objects in schema */ + +/* for database */ +#define OCI_ATTR_NCHARSET_ID 262 /* char set id */ +#define OCI_ATTR_LIST_SCHEMAS 263 /* list of schemas */ +#define OCI_ATTR_MAX_PROC_LEN 264 /* max procedure length */ +#define OCI_ATTR_MAX_COLUMN_LEN 265 /* max column name length */ +#define OCI_ATTR_CURSOR_COMMIT_BEHAVIOR 266 /* cursor commit behavior */ +#define OCI_ATTR_MAX_CATALOG_NAMELEN 267 /* catalog namelength */ +#define OCI_ATTR_CATALOG_LOCATION 268 /* catalog location */ +#define OCI_ATTR_SAVEPOINT_SUPPORT 269 /* savepoint support */ +#define OCI_ATTR_NOWAIT_SUPPORT 270 /* nowait support */ +#define OCI_ATTR_AUTOCOMMIT_DDL 271 /* autocommit DDL */ +#define OCI_ATTR_LOCKING_MODE 272 /* locking mode */ + +/* for externally initialized context */ +#define OCI_ATTR_APPCTX_SIZE 273 /* count of context to be init*/ +#define OCI_ATTR_APPCTX_LIST 274 /* count of context to be init*/ +#define OCI_ATTR_APPCTX_NAME 275 /* name of context to be init*/ +#define OCI_ATTR_APPCTX_ATTR 276 /* attr of context to be init*/ +#define OCI_ATTR_APPCTX_VALUE 277 /* value of context to be init*/ + +/* for client id propagation */ +#define OCI_ATTR_CLIENT_IDENTIFIER 278 /* value of client id to set*/ + +/* for inheritance - part 2 */ +#define OCI_ATTR_IS_FINAL_TYPE 279 /* is final type ? */ +#define OCI_ATTR_IS_INSTANTIABLE_TYPE 280 /* is instantiable type ? */ +#define OCI_ATTR_IS_FINAL_METHOD 281 /* is final method ? */ +#define OCI_ATTR_IS_INSTANTIABLE_METHOD 282 /* is instantiable method ? */ +#define OCI_ATTR_IS_OVERRIDING_METHOD 283 /* is overriding method ? */ + +#define OCI_ATTR_DESC_SYNBASE 284 /* Describe the base object */ + + +#define OCI_ATTR_CHAR_USED 285 /* char length semantics */ +#define OCI_ATTR_CHAR_SIZE 286 /* char length */ + +/* SQLJ support */ +#define OCI_ATTR_IS_JAVA_TYPE 287 /* is java implemented type ? */ + +/* N-Tier support */ +#define OCI_ATTR_DISTINGUISHED_NAME 300 /* use DN as user name */ +#define OCI_ATTR_KERBEROS_TICKET 301 /* Kerberos ticket as cred. */ + +/* for multilanguage debugging */ +#define OCI_ATTR_ORA_DEBUG_JDWP 302 /* ORA_DEBUG_JDWP attribute */ + +#define OCI_ATTR_EDITION 288 /* ORA_EDITION */ + +#define OCI_ATTR_RESERVED_14 303 /* reserved */ + + +/*---------------------------End Describe Handle Attributes -----------------*/ + +/* For values 303 - 307, see DirPathAPI attribute section in this file */ + +/* ----------------------- Session Pool Attributes ------------------------- */ +#define OCI_ATTR_SPOOL_TIMEOUT 308 /* session timeout */ +#define OCI_ATTR_SPOOL_GETMODE 309 /* session get mode */ +#define OCI_ATTR_SPOOL_BUSY_COUNT 310 /* busy session count */ +#define OCI_ATTR_SPOOL_OPEN_COUNT 311 /* open session count */ +#define OCI_ATTR_SPOOL_MIN 312 /* min session count */ +#define OCI_ATTR_SPOOL_MAX 313 /* max session count */ +#define OCI_ATTR_SPOOL_INCR 314 /* session increment count */ +#define OCI_ATTR_SPOOL_STMTCACHESIZE 208 /*Stmt cache size of pool */ +#define OCI_ATTR_SPOOL_AUTH 460 /* Auth handle on pool handle*/ +/*------------------------------End Session Pool Attributes -----------------*/ +/*---------------------------- For XML Types ------------------------------- */ +/* For table, view and column */ +#define OCI_ATTR_IS_XMLTYPE 315 /* Is the type an XML type? */ +#define OCI_ATTR_XMLSCHEMA_NAME 316 /* Name of XML Schema */ +#define OCI_ATTR_XMLELEMENT_NAME 317 /* Name of XML Element */ +#define OCI_ATTR_XMLSQLTYPSCH_NAME 318 /* SQL type's schema for XML Ele */ +#define OCI_ATTR_XMLSQLTYPE_NAME 319 /* Name of SQL type for XML Ele */ +#define OCI_ATTR_XMLTYPE_STORED_OBJ 320 /* XML type stored as object? */ +#define OCI_ATTR_XMLTYPE_BINARY_XML 422 /* XML type stored as binary? */ + +/*---------------------------- For Subtypes ------------------------------- */ +/* For type */ +#define OCI_ATTR_HAS_SUBTYPES 321 /* Has subtypes? */ +#define OCI_ATTR_NUM_SUBTYPES 322 /* Number of subtypes */ +#define OCI_ATTR_LIST_SUBTYPES 323 /* List of subtypes */ + +/* XML flag */ +#define OCI_ATTR_XML_HRCHY_ENABLED 324 /* hierarchy enabled? */ + +/* Method flag */ +#define OCI_ATTR_IS_OVERRIDDEN_METHOD 325 /* Method is overridden? */ + +/* For values 326 - 335, see DirPathAPI attribute section in this file */ + +/*------------- Attributes for 10i Distributed Objects ----------------------*/ +#define OCI_ATTR_OBJ_SUBS 336 /* obj col/tab substitutable */ + +/* For values 337 - 338, see DirPathAPI attribute section in this file */ + +/*---------- Attributes for 10i XADFIELD (NLS language, territory -----------*/ +#define OCI_ATTR_XADFIELD_RESERVED_1 339 /* reserved */ +#define OCI_ATTR_XADFIELD_RESERVED_2 340 /* reserved */ +/*------------- Kerberos Secure Client Identifier ---------------------------*/ +#define OCI_ATTR_KERBEROS_CID 341 /* Kerberos db service ticket*/ + + +/*------------------------ Attributes for Rules objects ---------------------*/ +#define OCI_ATTR_CONDITION 342 /* rule condition */ +#define OCI_ATTR_COMMENT 343 /* comment */ +#define OCI_ATTR_VALUE 344 /* Anydata value */ +#define OCI_ATTR_EVAL_CONTEXT_OWNER 345 /* eval context owner */ +#define OCI_ATTR_EVAL_CONTEXT_NAME 346 /* eval context name */ +#define OCI_ATTR_EVALUATION_FUNCTION 347 /* eval function name */ +#define OCI_ATTR_VAR_TYPE 348 /* variable type */ +#define OCI_ATTR_VAR_VALUE_FUNCTION 349 /* variable value function */ +#define OCI_ATTR_VAR_METHOD_FUNCTION 350 /* variable method function */ +#define OCI_ATTR_ACTION_CONTEXT 351 /* action context */ +#define OCI_ATTR_LIST_TABLE_ALIASES 352 /* list of table aliases */ +#define OCI_ATTR_LIST_VARIABLE_TYPES 353 /* list of variable types */ +#define OCI_ATTR_TABLE_NAME 356 /* table name */ + +/* For values 357 - 359, see DirPathAPI attribute section in this file */ + +#define OCI_ATTR_MESSAGE_CSCN 360 /* message cscn */ +#define OCI_ATTR_MESSAGE_DSCN 361 /* message dscn */ + +/*--------------------- Audit Session ID ------------------------------------*/ +#define OCI_ATTR_AUDIT_SESSION_ID 362 /* Audit session ID */ + +/*--------------------- Kerberos TGT Keys -----------------------------------*/ +#define OCI_ATTR_KERBEROS_KEY 363 /* n-tier Kerberos cred key */ +#define OCI_ATTR_KERBEROS_CID_KEY 364 /* SCID Kerberos cred key */ + + +#define OCI_ATTR_TRANSACTION_NO 365 /* AQ enq txn number */ + +/*----------------------- Attributes for End To End Tracing -----------------*/ +#define OCI_ATTR_MODULE 366 /* module for tracing */ +#define OCI_ATTR_ACTION 367 /* action for tracing */ +#define OCI_ATTR_CLIENT_INFO 368 /* client info */ +#define OCI_ATTR_COLLECT_CALL_TIME 369 /* collect call time */ +#define OCI_ATTR_CALL_TIME 370 /* extract call time */ +#define OCI_ATTR_ECONTEXT_ID 371 /* execution-id context */ +#define OCI_ATTR_ECONTEXT_SEQ 372 /*execution-id sequence num */ + + +/*------------------------------ Session attributes -------------------------*/ +#define OCI_ATTR_SESSION_STATE 373 /* session state */ +#define OCI_SESSION_STATELESS 1 /* valid states */ +#define OCI_SESSION_STATEFUL 2 + +#define OCI_ATTR_SESSION_STATETYPE 374 /* session state type */ +#define OCI_SESSION_STATELESS_DEF 0 /* valid state types */ +#define OCI_SESSION_STATELESS_CAL 1 +#define OCI_SESSION_STATELESS_TXN 2 +#define OCI_SESSION_STATELESS_APP 3 + +#define OCI_ATTR_SESSION_STATE_CLEARED 376 /* session state cleared */ +#define OCI_ATTR_SESSION_MIGRATED 377 /* did session migrate */ +#define OCI_ATTR_SESSION_PRESERVE_STATE 388 /* preserve session state */ +#define OCI_ATTR_DRIVER_NAME 424 /* Driver Name */ + +/* -------------------------- Admin Handle Attributes ---------------------- */ + +#define OCI_ATTR_ADMIN_PFILE 389 /* client-side param file */ + +/*----------------------- Attributes for End To End Tracing -----------------*/ +/* -------------------------- HA Event Handle Attributes ------------------- */ + +#define OCI_ATTR_HOSTNAME 390 /* SYS_CONTEXT hostname */ +#define OCI_ATTR_DBNAME 391 /* SYS_CONTEXT dbname */ +#define OCI_ATTR_INSTNAME 392 /* SYS_CONTEXT instance name */ +#define OCI_ATTR_SERVICENAME 393 /* SYS_CONTEXT service name */ +#define OCI_ATTR_INSTSTARTTIME 394 /* v$instance instance start time */ +#define OCI_ATTR_HA_TIMESTAMP 395 /* event time */ +#define OCI_ATTR_RESERVED_22 396 /* reserved */ +#define OCI_ATTR_RESERVED_23 397 /* reserved */ +#define OCI_ATTR_RESERVED_24 398 /* reserved */ +#define OCI_ATTR_DBDOMAIN 399 /* db domain */ +#define OCI_ATTR_RESERVED_27 425 /* reserved */ + +#define OCI_ATTR_EVENTTYPE 400 /* event type */ +#define OCI_EVENTTYPE_HA 0 /* valid value for OCI_ATTR_EVENTTYPE */ + +#define OCI_ATTR_HA_SOURCE 401 +/* valid values for OCI_ATTR_HA_SOURCE */ +#define OCI_HA_SOURCE_INSTANCE 0 +#define OCI_HA_SOURCE_DATABASE 1 +#define OCI_HA_SOURCE_NODE 2 +#define OCI_HA_SOURCE_SERVICE 3 +#define OCI_HA_SOURCE_SERVICE_MEMBER 4 +#define OCI_HA_SOURCE_ASM_INSTANCE 5 +#define OCI_HA_SOURCE_SERVICE_PRECONNECT 6 + +#define OCI_ATTR_HA_STATUS 402 +#define OCI_HA_STATUS_DOWN 0 /* valid values for OCI_ATTR_HA_STATUS */ +#define OCI_HA_STATUS_UP 1 + +#define OCI_ATTR_HA_SRVFIRST 403 + +#define OCI_ATTR_HA_SRVNEXT 404 +/* ------------------------- Server Handle Attributes -----------------------*/ + +#define OCI_ATTR_TAF_ENABLED 405 + +/* Extra notification attributes */ +#define OCI_ATTR_NFY_FLAGS 406 + +#define OCI_ATTR_MSG_DELIVERY_MODE 407 /* msg delivery mode */ +#define OCI_ATTR_DB_CHARSET_ID 416 /* database charset ID */ +#define OCI_ATTR_DB_NCHARSET_ID 417 /* database ncharset ID */ +#define OCI_ATTR_RESERVED_25 418 /* reserved */ + +#define OCI_ATTR_FLOW_CONTROL_TIMEOUT 423 /* AQ: flow control timeout */ +/*---------------------------------------------------------------------------*/ +/* ------------------DirPathAPI attribute Section----------------------------*/ +/* All DirPathAPI attributes are in this section of the file. Existing */ +/* attributes prior to this section being created are assigned values < 2000 */ +/* Add new DirPathAPI attributes to this section and their assigned value */ +/* should be whatever the last entry is + 1. */ + +/*------------- Supported Values for Direct Path Stream Version -------------*/ +#define OCI_DIRPATH_STREAM_VERSION_1 100 +#define OCI_DIRPATH_STREAM_VERSION_2 200 +#define OCI_DIRPATH_STREAM_VERSION_3 300 /* default */ + + +#define OCI_ATTR_DIRPATH_MODE 78 /* mode of direct path operation */ +#define OCI_ATTR_DIRPATH_NOLOG 79 /* nologging option */ +#define OCI_ATTR_DIRPATH_PARALLEL 80 /* parallel (temp seg) option */ + +#define OCI_ATTR_DIRPATH_SORTED_INDEX 137 /* index that data is sorted on */ + + /* direct path index maint method (see oci8dp.h) */ +#define OCI_ATTR_DIRPATH_INDEX_MAINT_METHOD 138 + + /* parallel load: db file, initial and next extent sizes */ + +#define OCI_ATTR_DIRPATH_FILE 139 /* DB file to load into */ +#define OCI_ATTR_DIRPATH_STORAGE_INITIAL 140 /* initial extent size */ +#define OCI_ATTR_DIRPATH_STORAGE_NEXT 141 /* next extent size */ + /* direct path index maint method (see oci8dp.h) */ +#define OCI_ATTR_DIRPATH_SKIPINDEX_METHOD 145 + + /* 8.2 dpapi support of ADTs */ +#define OCI_ATTR_DIRPATH_EXPR_TYPE 150 /* expr type of OCI_ATTR_NAME */ + +/* For the direct path API there are three data formats: + * TEXT - used mainly by SQL*Loader, data is in textual form + * STREAM - used by datapump, data is in stream loadable form + * OCI - used by OCI programs utilizing the DpApi, data is in binary form + */ +#define OCI_ATTR_DIRPATH_INPUT 151 +#define OCI_DIRPATH_INPUT_TEXT 0x01 /* text */ +#define OCI_DIRPATH_INPUT_STREAM 0x02 /* stream (datapump) */ +#define OCI_DIRPATH_INPUT_OCI 0x04 /* binary (oci) */ +#define OCI_DIRPATH_INPUT_UNKNOWN 0x08 + +#define OCI_ATTR_DIRPATH_FN_CTX 167 /* fn ctx ADT attrs or args */ + +#define OCI_ATTR_DIRPATH_OID 187 /* loading into an OID col */ +#define OCI_ATTR_DIRPATH_SID 194 /* loading into an SID col */ +#define OCI_ATTR_DIRPATH_OBJ_CONSTR 206 /* obj type of subst obj tbl */ + +/* Attr to allow setting of the stream version PRIOR to calling Prepare */ +#define OCI_ATTR_DIRPATH_STREAM_VERSION 212 /* version of the stream*/ + +#define OCIP_ATTR_DIRPATH_VARRAY_INDEX 213 /* varray index column */ + +/*------------- Supported Values for Direct Path Date cache -----------------*/ +#define OCI_ATTR_DIRPATH_DCACHE_NUM 303 /* date cache entries */ +#define OCI_ATTR_DIRPATH_DCACHE_SIZE 304 /* date cache limit */ +#define OCI_ATTR_DIRPATH_DCACHE_MISSES 305 /* date cache misses */ +#define OCI_ATTR_DIRPATH_DCACHE_HITS 306 /* date cache hits */ +#define OCI_ATTR_DIRPATH_DCACHE_DISABLE 307 /* on set: disable datecache + * on overflow. + * on get: datecache disabled? + * could be due to overflow + * or others */ + +/*------------- Attributes for 10i Updates to the DirPath API ---------------*/ +#define OCI_ATTR_DIRPATH_RESERVED_7 326 /* reserved */ +#define OCI_ATTR_DIRPATH_RESERVED_8 327 /* reserved */ +#define OCI_ATTR_DIRPATH_CONVERT 328 /* stream conversion needed? */ +#define OCI_ATTR_DIRPATH_BADROW 329 /* info about bad row */ +#define OCI_ATTR_DIRPATH_BADROW_LENGTH 330 /* length of bad row info */ +#define OCI_ATTR_DIRPATH_WRITE_ORDER 331 /* column fill order */ +#define OCI_ATTR_DIRPATH_GRANULE_SIZE 332 /* granule size for unload */ +#define OCI_ATTR_DIRPATH_GRANULE_OFFSET 333 /* offset to last granule */ +#define OCI_ATTR_DIRPATH_RESERVED_1 334 /* reserved */ +#define OCI_ATTR_DIRPATH_RESERVED_2 335 /* reserved */ + +/*------ Attributes for 10i DirPathAPI conversion (NLS lang, terr, cs) ------*/ +#define OCI_ATTR_DIRPATH_RESERVED_3 337 /* reserved */ +#define OCI_ATTR_DIRPATH_RESERVED_4 338 /* reserved */ +#define OCI_ATTR_DIRPATH_RESERVED_5 357 /* reserved */ +#define OCI_ATTR_DIRPATH_RESERVED_6 358 /* reserved */ + +#define OCI_ATTR_DIRPATH_LOCK_WAIT 359 /* wait for lock in dpapi */ + +#define OCI_ATTR_DIRPATH_RESERVED_9 2000 /* reserved */ + +/*------ Attribute for 10iR2 for column encryption for Direct Path API ------*/ +#define OCI_ATTR_DIRPATH_RESERVED_10 2001 /* reserved */ +#define OCI_ATTR_DIRPATH_RESERVED_11 2002 /* reserved */ + +/*------ Attribute to determine last column successfully converted ----------*/ +#define OCI_ATTR_CURRENT_ERRCOL 2003 /* current error column */ + + /*--Attributes for 11gR1 for multiple subtype support in Direct Path API - */ +#define OCI_ATTR_DIRPATH_SUBTYPE_INDEX 2004 /* sbtyp indx for attribute */ + +#define OCI_ATTR_DIRPATH_RESERVED_12 2005 /* reserved */ +#define OCI_ATTR_DIRPATH_RESERVED_13 2006 /* reserver */ + + /*--Attribute for partitioning constraint optimization in Direct Path API */ +#define OCI_ATTR_DIRPATH_RESERVED_14 2007 /* reserved */ + + /*--Attribute for interval partitioning in Direct Path API */ +#define OCI_ATTR_DIRPATH_RESERVED_15 2008 /* reserved */ + + /*--Attribute for interval partitioning in Direct Path API */ +#define OCI_ATTR_DIRPATH_RESERVED_16 2009 /* reserved */ + +/*--Attribute for allowing parallel lob loads in Direct Path API */ +#define OCI_ATTR_DIRPATH_RESERVED_17 2010 /* reserved */ + +/*--Attribute for process order number of table being loaded/unloaded */ +#define OCI_ATTR_DIRPATH_RESERVED_18 2011 /* reserved */ + +#define OCI_ATTR_DIRPATH_RESERVED_19 2012 /* reserved */ + +#define OCI_ATTR_DIRPATH_NO_INDEX_ERRORS 2013 /* reserved */ + +/*--Attribute for private sqlldr no index errors */ +#define OCI_ATTR_DIRPATH_RESERVED_20 2014 /* reserved */ + +/*--Attribute for private sqlldr partition memory limit */ +#define OCI_ATTR_DIRPATH_RESERVED_21 2015 /* reserved */ + +/* Add DirPathAPI attributes above. Next value to be assigned is 2016 */ + + +/* ------------------End of DirPathAPI attribute Section --------------------*/ +/*---------------------------------------------------------------------------*/ + + +/*---------------- Describe Handle Parameter Attribute Values ---------------*/ + +/* OCI_ATTR_CURSOR_COMMIT_BEHAVIOR */ +#define OCI_CURSOR_OPEN 0 +#define OCI_CURSOR_CLOSED 1 + +/* OCI_ATTR_CATALOG_LOCATION */ +#define OCI_CL_START 0 +#define OCI_CL_END 1 + +/* OCI_ATTR_SAVEPOINT_SUPPORT */ +#define OCI_SP_SUPPORTED 0 +#define OCI_SP_UNSUPPORTED 1 + +/* OCI_ATTR_NOWAIT_SUPPORT */ +#define OCI_NW_SUPPORTED 0 +#define OCI_NW_UNSUPPORTED 1 + +/* OCI_ATTR_AUTOCOMMIT_DDL */ +#define OCI_AC_DDL 0 +#define OCI_NO_AC_DDL 1 + +/* OCI_ATTR_LOCKING_MODE */ +#define OCI_LOCK_IMMEDIATE 0 +#define OCI_LOCK_DELAYED 1 + +/* ------------------- Instance type attribute values -----------------------*/ +#define OCI_INSTANCE_TYPE_UNKNOWN 0 +#define OCI_INSTANCE_TYPE_RDBMS 1 +#define OCI_INSTANCE_TYPE_OSM 2 + +/* ---------------- ASM Volume Device Support attribute values --------------*/ +#define OCI_ASM_VOLUME_UNSUPPORTED 0 +#define OCI_ASM_VOLUME_SUPPORTED 1 + +/*---------------------------------------------------------------------------*/ + +/*---------------------------OCIPasswordChange-------------------------------*/ +#define OCI_AUTH 0x08 /* Change the password but do not login */ + + +/*------------------------Other Constants------------------------------------*/ +#define OCI_MAX_FNS 100 /* max number of OCI Functions */ +#define OCI_SQLSTATE_SIZE 5 +#define OCI_ERROR_MAXMSG_SIZE 1024 /* max size of an error message */ +#define OCI_LOBMAXSIZE MINUB4MAXVAL /* maximum lob data size */ +#define OCI_ROWID_LEN 23 +#define OCI_LOB_CONTENTTYPE_MAXSIZE 128 /* max size of securefile contenttype */ +#define OCI_LOB_CONTENTTYPE_MAXBYTESIZE OCI_LOB_CONTENTTYPE_MAXSIZE +/*---------------------------------------------------------------------------*/ + +/*------------------------ Fail Over Events ---------------------------------*/ +#define OCI_FO_END 0x00000001 +#define OCI_FO_ABORT 0x00000002 +#define OCI_FO_REAUTH 0x00000004 +#define OCI_FO_BEGIN 0x00000008 +#define OCI_FO_ERROR 0x00000010 +/*---------------------------------------------------------------------------*/ + +/*------------------------ Fail Over Callback Return Codes ------------------*/ +#define OCI_FO_RETRY 25410 +/*---------------------------------------------------------------------------*/ + +/*------------------------- Fail Over Types ---------------------------------*/ +#define OCI_FO_NONE 0x00000001 +#define OCI_FO_SESSION 0x00000002 +#define OCI_FO_SELECT 0x00000004 +#define OCI_FO_TXNAL 0x00000008 +/*---------------------------------------------------------------------------*/ + +/*-----------------------Function Codes--------------------------------------*/ +#define OCI_FNCODE_INITIALIZE 1 /* OCIInitialize */ +#define OCI_FNCODE_HANDLEALLOC 2 /* OCIHandleAlloc */ +#define OCI_FNCODE_HANDLEFREE 3 /* OCIHandleFree */ +#define OCI_FNCODE_DESCRIPTORALLOC 4 /* OCIDescriptorAlloc */ +#define OCI_FNCODE_DESCRIPTORFREE 5 /* OCIDescriptorFree */ +#define OCI_FNCODE_ENVINIT 6 /* OCIEnvInit */ +#define OCI_FNCODE_SERVERATTACH 7 /* OCIServerAttach */ +#define OCI_FNCODE_SERVERDETACH 8 /* OCIServerDetach */ +/* unused 9 */ +#define OCI_FNCODE_SESSIONBEGIN 10 /* OCISessionBegin */ +#define OCI_FNCODE_SESSIONEND 11 /* OCISessionEnd */ +#define OCI_FNCODE_PASSWORDCHANGE 12 /* OCIPasswordChange */ +#define OCI_FNCODE_STMTPREPARE 13 /* OCIStmtPrepare */ + /* unused 14- 16 */ +#define OCI_FNCODE_BINDDYNAMIC 17 /* OCIBindDynamic */ +#define OCI_FNCODE_BINDOBJECT 18 /* OCIBindObject */ + /* 19 unused */ +#define OCI_FNCODE_BINDARRAYOFSTRUCT 20 /* OCIBindArrayOfStruct */ +#define OCI_FNCODE_STMTEXECUTE 21 /* OCIStmtExecute */ + /* unused 22-24 */ +#define OCI_FNCODE_DEFINEOBJECT 25 /* OCIDefineObject */ +#define OCI_FNCODE_DEFINEDYNAMIC 26 /* OCIDefineDynamic */ +#define OCI_FNCODE_DEFINEARRAYOFSTRUCT 27 /* OCIDefineArrayOfStruct */ +#define OCI_FNCODE_STMTFETCH 28 /* OCIStmtFetch */ +#define OCI_FNCODE_STMTGETBIND 29 /* OCIStmtGetBindInfo */ + /* 30, 31 unused */ +#define OCI_FNCODE_DESCRIBEANY 32 /* OCIDescribeAny */ +#define OCI_FNCODE_TRANSSTART 33 /* OCITransStart */ +#define OCI_FNCODE_TRANSDETACH 34 /* OCITransDetach */ +#define OCI_FNCODE_TRANSCOMMIT 35 /* OCITransCommit */ + /* 36 unused */ +#define OCI_FNCODE_ERRORGET 37 /* OCIErrorGet */ +#define OCI_FNCODE_LOBOPENFILE 38 /* OCILobFileOpen */ +#define OCI_FNCODE_LOBCLOSEFILE 39 /* OCILobFileClose */ + /* 40 was LOBCREATEFILE, unused */ + /* 41 was OCILobFileDelete, unused */ +#define OCI_FNCODE_LOBCOPY 42 /* OCILobCopy */ +#define OCI_FNCODE_LOBAPPEND 43 /* OCILobAppend */ +#define OCI_FNCODE_LOBERASE 44 /* OCILobErase */ +#define OCI_FNCODE_LOBLENGTH 45 /* OCILobGetLength */ +#define OCI_FNCODE_LOBTRIM 46 /* OCILobTrim */ +#define OCI_FNCODE_LOBREAD 47 /* OCILobRead */ +#define OCI_FNCODE_LOBWRITE 48 /* OCILobWrite */ + /* 49 unused */ +#define OCI_FNCODE_SVCCTXBREAK 50 /* OCIBreak */ +#define OCI_FNCODE_SERVERVERSION 51 /* OCIServerVersion */ + +#define OCI_FNCODE_KERBATTRSET 52 /* OCIKerbAttrSet */ + +/* unused 53 */ + +#define OCI_FNCODE_ATTRGET 54 /* OCIAttrGet */ +#define OCI_FNCODE_ATTRSET 55 /* OCIAttrSet */ +#define OCI_FNCODE_PARAMSET 56 /* OCIParamSet */ +#define OCI_FNCODE_PARAMGET 57 /* OCIParamGet */ +#define OCI_FNCODE_STMTGETPIECEINFO 58 /* OCIStmtGetPieceInfo */ +#define OCI_FNCODE_LDATOSVCCTX 59 /* OCILdaToSvcCtx */ + /* 60 unused */ +#define OCI_FNCODE_STMTSETPIECEINFO 61 /* OCIStmtSetPieceInfo */ +#define OCI_FNCODE_TRANSFORGET 62 /* OCITransForget */ +#define OCI_FNCODE_TRANSPREPARE 63 /* OCITransPrepare */ +#define OCI_FNCODE_TRANSROLLBACK 64 /* OCITransRollback */ +#define OCI_FNCODE_DEFINEBYPOS 65 /* OCIDefineByPos */ +#define OCI_FNCODE_BINDBYPOS 66 /* OCIBindByPos */ +#define OCI_FNCODE_BINDBYNAME 67 /* OCIBindByName */ +#define OCI_FNCODE_LOBASSIGN 68 /* OCILobAssign */ +#define OCI_FNCODE_LOBISEQUAL 69 /* OCILobIsEqual */ +#define OCI_FNCODE_LOBISINIT 70 /* OCILobLocatorIsInit */ + +#define OCI_FNCODE_LOBENABLEBUFFERING 71 /* OCILobEnableBuffering */ +#define OCI_FNCODE_LOBCHARSETID 72 /* OCILobCharSetID */ +#define OCI_FNCODE_LOBCHARSETFORM 73 /* OCILobCharSetForm */ +#define OCI_FNCODE_LOBFILESETNAME 74 /* OCILobFileSetName */ +#define OCI_FNCODE_LOBFILEGETNAME 75 /* OCILobFileGetName */ +#define OCI_FNCODE_LOGON 76 /* OCILogon */ +#define OCI_FNCODE_LOGOFF 77 /* OCILogoff */ +#define OCI_FNCODE_LOBDISABLEBUFFERING 78 /* OCILobDisableBuffering */ +#define OCI_FNCODE_LOBFLUSHBUFFER 79 /* OCILobFlushBuffer */ +#define OCI_FNCODE_LOBLOADFROMFILE 80 /* OCILobLoadFromFile */ + +#define OCI_FNCODE_LOBOPEN 81 /* OCILobOpen */ +#define OCI_FNCODE_LOBCLOSE 82 /* OCILobClose */ +#define OCI_FNCODE_LOBISOPEN 83 /* OCILobIsOpen */ +#define OCI_FNCODE_LOBFILEISOPEN 84 /* OCILobFileIsOpen */ +#define OCI_FNCODE_LOBFILEEXISTS 85 /* OCILobFileExists */ +#define OCI_FNCODE_LOBFILECLOSEALL 86 /* OCILobFileCloseAll */ +#define OCI_FNCODE_LOBCREATETEMP 87 /* OCILobCreateTemporary */ +#define OCI_FNCODE_LOBFREETEMP 88 /* OCILobFreeTemporary */ +#define OCI_FNCODE_LOBISTEMP 89 /* OCILobIsTemporary */ + +#define OCI_FNCODE_AQENQ 90 /* OCIAQEnq */ +#define OCI_FNCODE_AQDEQ 91 /* OCIAQDeq */ +#define OCI_FNCODE_RESET 92 /* OCIReset */ +#define OCI_FNCODE_SVCCTXTOLDA 93 /* OCISvcCtxToLda */ +#define OCI_FNCODE_LOBLOCATORASSIGN 94 /* OCILobLocatorAssign */ + +#define OCI_FNCODE_UBINDBYNAME 95 + +#define OCI_FNCODE_AQLISTEN 96 /* OCIAQListen */ + +#define OCI_FNCODE_SVC2HST 97 /* reserved */ +#define OCI_FNCODE_SVCRH 98 /* reserved */ + /* 97 and 98 are reserved for Oracle internal use */ + +#define OCI_FNCODE_TRANSMULTIPREPARE 99 /* OCITransMultiPrepare */ + +#define OCI_FNCODE_CPOOLCREATE 100 /* OCIConnectionPoolCreate */ +#define OCI_FNCODE_CPOOLDESTROY 101 /* OCIConnectionPoolDestroy */ +#define OCI_FNCODE_LOGON2 102 /* OCILogon2 */ +#define OCI_FNCODE_ROWIDTOCHAR 103 /* OCIRowidToChar */ + +#define OCI_FNCODE_SPOOLCREATE 104 /* OCISessionPoolCreate */ +#define OCI_FNCODE_SPOOLDESTROY 105 /* OCISessionPoolDestroy */ +#define OCI_FNCODE_SESSIONGET 106 /* OCISessionGet */ +#define OCI_FNCODE_SESSIONRELEASE 107 /* OCISessionRelease */ +#define OCI_FNCODE_STMTPREPARE2 108 /* OCIStmtPrepare2 */ +#define OCI_FNCODE_STMTRELEASE 109 /* OCIStmtRelease */ +#define OCI_FNCODE_AQENQARRAY 110 /* OCIAQEnqArray */ +#define OCI_FNCODE_AQDEQARRAY 111 /* OCIAQDeqArray */ +#define OCI_FNCODE_LOBCOPY2 112 /* OCILobCopy2 */ +#define OCI_FNCODE_LOBERASE2 113 /* OCILobErase2 */ +#define OCI_FNCODE_LOBLENGTH2 114 /* OCILobGetLength2 */ +#define OCI_FNCODE_LOBLOADFROMFILE2 115 /* OCILobLoadFromFile2 */ +#define OCI_FNCODE_LOBREAD2 116 /* OCILobRead2 */ +#define OCI_FNCODE_LOBTRIM2 117 /* OCILobTrim2 */ +#define OCI_FNCODE_LOBWRITE2 118 /* OCILobWrite2 */ +#define OCI_FNCODE_LOBGETSTORAGELIMIT 119 /* OCILobGetStorageLimit */ +#define OCI_FNCODE_DBSTARTUP 120 /* OCIDBStartup */ +#define OCI_FNCODE_DBSHUTDOWN 121 /* OCIDBShutdown */ +#define OCI_FNCODE_LOBARRAYREAD 122 /* OCILobArrayRead */ +#define OCI_FNCODE_LOBARRAYWRITE 123 /* OCILobArrayWrite */ +#define OCI_FNCODE_AQENQSTREAM 124 /* OCIAQEnqStreaming */ +#define OCI_FNCODE_AQGETREPLAY 125 /* OCIAQGetReplayInfo */ +#define OCI_FNCODE_AQRESETREPLAY 126 /* OCIAQResetReplayInfo */ +#define OCI_FNCODE_ARRAYDESCRIPTORALLOC 127 /*OCIArrayDescriptorAlloc */ +#define OCI_FNCODE_ARRAYDESCRIPTORFREE 128 /* OCIArrayDescriptorFree */ +#define OCI_FNCODE_LOBGETOPT 129 /* OCILobGetCptions */ +#define OCI_FNCODE_LOBSETOPT 130 /* OCILobSetCptions */ +#define OCI_FNCODE_LOBFRAGINS 131 /* OCILobFragementInsert */ +#define OCI_FNCODE_LOBFRAGDEL 132 /* OCILobFragementDelete */ +#define OCI_FNCODE_LOBFRAGMOV 133 /* OCILobFragementMove */ +#define OCI_FNCODE_LOBFRAGREP 134 /* OCILobFragementReplace */ +#define OCI_FNCODE_LOBGETDEDUPLICATEREGIONS 135/* OCILobGetDeduplicateRegions */ +#define OCI_FNCODE_APPCTXSET 136 /* OCIAppCtxSet */ +#define OCI_FNCODE_APPCTXCLEARALL 137 /* OCIAppCtxClearAll */ + +#define OCI_FNCODE_LOBGETCONTENTTYPE 138 /* OCILobGetContentType */ +#define OCI_FNCODE_LOBSETCONTENTTYPE 139 /* OCILobSetContentType */ +#define OCI_FNCODE_MAXFCN 139 /* maximum OCI function code */ + +/*---------------Statement Cache callback modes-----------------------------*/ +#define OCI_CBK_STMTCACHE_STMTPURGE 0x01 + +/*---------------------------------------------------------------------------*/ + +/*-----------------------Handle Definitions----------------------------------*/ +typedef struct OCIEnv OCIEnv; /* OCI environment handle */ +typedef struct OCIError OCIError; /* OCI error handle */ +typedef struct OCISvcCtx OCISvcCtx; /* OCI service handle */ +typedef struct OCIStmt OCIStmt; /* OCI statement handle */ +typedef struct OCIBind OCIBind; /* OCI bind handle */ +typedef struct OCIDefine OCIDefine; /* OCI Define handle */ +typedef struct OCIDescribe OCIDescribe; /* OCI Describe handle */ +typedef struct OCIServer OCIServer; /* OCI Server handle */ +typedef struct OCISession OCISession; /* OCI Authentication handle */ +typedef struct OCIComplexObject OCIComplexObject; /* OCI COR handle */ +typedef struct OCITrans OCITrans; /* OCI Transaction handle */ +typedef struct OCISecurity OCISecurity; /* OCI Security handle */ +typedef struct OCISubscription OCISubscription; /* subscription handle */ + +typedef struct OCICPool OCICPool; /* connection pool handle */ +typedef struct OCISPool OCISPool; /* session pool handle */ +typedef struct OCIAuthInfo OCIAuthInfo; /* auth handle */ +typedef struct OCIAdmin OCIAdmin; /* admin handle */ +typedef struct OCIEvent OCIEvent; /* HA event handle */ + +/*-----------------------Descriptor Definitions------------------------------*/ +typedef struct OCISnapshot OCISnapshot; /* OCI snapshot descriptor */ +typedef struct OCIResult OCIResult; /* OCI Result Set Descriptor */ +typedef struct OCILobLocator OCILobLocator; /* OCI Lob Locator descriptor */ +typedef struct OCILobRegion OCILobRegion; /* OCI Lob Regions descriptor */ +typedef struct OCIParam OCIParam; /* OCI PARameter descriptor */ +typedef struct OCIComplexObjectComp OCIComplexObjectComp; + /* OCI COR descriptor */ +typedef struct OCIRowid OCIRowid; /* OCI ROWID descriptor */ + +typedef struct OCIDateTime OCIDateTime; /* OCI DateTime descriptor */ +typedef struct OCIInterval OCIInterval; /* OCI Interval descriptor */ + +typedef struct OCIUcb OCIUcb; /* OCI User Callback descriptor */ +typedef struct OCIServerDNs OCIServerDNs; /* OCI server DN descriptor */ + +/*-------------------------- AQ Descriptors ---------------------------------*/ +typedef struct OCIAQEnqOptions OCIAQEnqOptions; /* AQ Enqueue Options hdl */ +typedef struct OCIAQDeqOptions OCIAQDeqOptions; /* AQ Dequeue Options hdl */ +typedef struct OCIAQMsgProperties OCIAQMsgProperties; /* AQ Mesg Properties */ +typedef struct OCIAQAgent OCIAQAgent; /* AQ Agent descriptor */ +typedef struct OCIAQNfyDescriptor OCIAQNfyDescriptor; /* AQ Nfy descriptor */ +typedef struct OCIAQSignature OCIAQSignature; /* AQ Siganture */ +typedef struct OCIAQListenOpts OCIAQListenOpts; /* AQ listen options */ +typedef struct OCIAQLisMsgProps OCIAQLisMsgProps; /* AQ listen msg props */ + +/*---------------------------------------------------------------------------*/ + +/* Lob typedefs for Pro*C */ +typedef struct OCILobLocator OCIClobLocator; /* OCI Character LOB Locator */ +typedef struct OCILobLocator OCIBlobLocator; /* OCI Binary LOB Locator */ +typedef struct OCILobLocator OCIBFileLocator; /* OCI Binary LOB File Locator */ +/*---------------------------------------------------------------------------*/ + +/* Undefined value for tz in interval types*/ +#define OCI_INTHR_UNK 24 + + /* These defined adjustment values */ +#define OCI_ADJUST_UNK 10 +#define OCI_ORACLE_DATE 0 +#define OCI_ANSI_DATE 1 + +/*------------------------ Lob-specific Definitions -------------------------*/ + +/* + * ociloff - OCI Lob OFFset + * + * The offset in the lob data. The offset is specified in terms of bytes for + * BLOBs and BFILes. Character offsets are used for CLOBs, NCLOBs. + * The maximum size of internal lob data is 4 gigabytes. FILE LOB + * size is limited by the operating system. + */ +typedef ub4 OCILobOffset; + +/* + * ocillen - OCI Lob LENgth (of lob data) + * + * Specifies the length of lob data in bytes for BLOBs and BFILes and in + * characters for CLOBs, NCLOBs. The maximum length of internal lob + * data is 4 gigabytes. The length of FILE LOBs is limited only by the + * operating system. + */ +typedef ub4 OCILobLength; +/* + * ocilmo - OCI Lob open MOdes + * + * The mode specifies the planned operations that will be performed on the + * FILE lob data. The FILE lob can be opened in read-only mode only. + * + * In the future, we may include read/write, append and truncate modes. Append + * is equivalent to read/write mode except that the FILE is positioned for + * writing to the end. Truncate is equivalent to read/write mode except that + * the FILE LOB data is first truncated to a length of 0 before use. + */ +enum OCILobMode +{ + OCI_LOBMODE_READONLY = 1, /* read-only */ + OCI_LOBMODE_READWRITE = 2 /* read_write for internal lobs only */ +}; +typedef enum OCILobMode OCILobMode; + +/*---------------------------------------------------------------------------*/ + + +/*----------------------------Piece Definitions------------------------------*/ + +/* if ocidef.h is being included in the app, ocidef.h should precede oci.h */ + +/* + * since clients may use oci.h, ocidef.h and ocidfn.h the following defines + * need to be guarded, usually internal clients + */ + +#ifndef OCI_FLAGS +#define OCI_FLAGS +#define OCI_ONE_PIECE 0 /* one piece */ +#define OCI_FIRST_PIECE 1 /* the first piece */ +#define OCI_NEXT_PIECE 2 /* the next of many pieces */ +#define OCI_LAST_PIECE 3 /* the last piece */ +#endif +/*---------------------------------------------------------------------------*/ + +/*--------------------------- FILE open modes -------------------------------*/ +#define OCI_FILE_READONLY 1 /* readonly mode open for FILE types */ +/*---------------------------------------------------------------------------*/ +/*--------------------------- LOB open modes --------------------------------*/ +#define OCI_LOB_READONLY 1 /* readonly mode open for ILOB types */ +#define OCI_LOB_READWRITE 2 /* read write mode open for ILOBs */ +#define OCI_LOB_WRITEONLY 3 /* Writeonly mode open for ILOB types*/ +#define OCI_LOB_APPENDONLY 4 /* Appendonly mode open for ILOB types */ +#define OCI_LOB_FULLOVERWRITE 5 /* Completely overwrite ILOB */ +#define OCI_LOB_FULLREAD 6 /* Doing a Full Read of ILOB */ + +/*----------------------- LOB Buffering Flush Flags -------------------------*/ +#define OCI_LOB_BUFFER_FREE 1 +#define OCI_LOB_BUFFER_NOFREE 2 +/*---------------------------------------------------------------------------*/ + +/*---------------------------LOB Option Types -------------------------------*/ +#define OCI_LOB_OPT_COMPRESS 1 /* SECUREFILE Compress */ +#define OCI_LOB_OPT_ENCRYPT 2 /* SECUREFILE Encrypt */ +#define OCI_LOB_OPT_DEDUPLICATE 4 /* SECUREFILE Deduplicate */ +#define OCI_LOB_OPT_ALLOCSIZE 8 /* SECUREFILE Allocation Size */ +#define OCI_LOB_OPT_CONTENTTYPE 16 /* SECUREFILE Content Type */ +#define OCI_LOB_OPT_MODTIME 32 /* SECUREFILE Modification Time */ + +/*------------------------ LOB Option Values ------------------------------*/ +/* Compression */ +#define OCI_LOB_COMPRESS_OFF 0 /* Compression off */ +#define OCI_LOB_COMPRESS_ON 1 /* Compression on */ +/* Encryption */ +#define OCI_LOB_ENCRYPT_OFF 0 /* Encryption Off */ +#define OCI_LOB_ENCRYPT_ON 2 /* Encryption On */ +/* Deduplciate */ +#define OCI_LOB_DEDUPLICATE_OFF 0 /* Deduplicate Off */ +#define OCI_LOB_DEDUPLICATE_ON 4 /* Deduplicate Lobs */ + +/*--------------------------- OCI Statement Types ---------------------------*/ + +#define OCI_STMT_UNKNOWN 0 /* Unknown statement */ +#define OCI_STMT_SELECT 1 /* select statement */ +#define OCI_STMT_UPDATE 2 /* update statement */ +#define OCI_STMT_DELETE 3 /* delete statement */ +#define OCI_STMT_INSERT 4 /* Insert Statement */ +#define OCI_STMT_CREATE 5 /* create statement */ +#define OCI_STMT_DROP 6 /* drop statement */ +#define OCI_STMT_ALTER 7 /* alter statement */ +#define OCI_STMT_BEGIN 8 /* begin ... (pl/sql statement)*/ +#define OCI_STMT_DECLARE 9 /* declare .. (pl/sql statement ) */ +#define OCI_STMT_CALL 10 /* corresponds to kpu call */ +/*---------------------------------------------------------------------------*/ + +/*--------------------------- OCI Parameter Types ---------------------------*/ +#define OCI_PTYPE_UNK 0 /* unknown */ +#define OCI_PTYPE_TABLE 1 /* table */ +#define OCI_PTYPE_VIEW 2 /* view */ +#define OCI_PTYPE_PROC 3 /* procedure */ +#define OCI_PTYPE_FUNC 4 /* function */ +#define OCI_PTYPE_PKG 5 /* package */ +#define OCI_PTYPE_TYPE 6 /* user-defined type */ +#define OCI_PTYPE_SYN 7 /* synonym */ +#define OCI_PTYPE_SEQ 8 /* sequence */ +#define OCI_PTYPE_COL 9 /* column */ +#define OCI_PTYPE_ARG 10 /* argument */ +#define OCI_PTYPE_LIST 11 /* list */ +#define OCI_PTYPE_TYPE_ATTR 12 /* user-defined type's attribute */ +#define OCI_PTYPE_TYPE_COLL 13 /* collection type's element */ +#define OCI_PTYPE_TYPE_METHOD 14 /* user-defined type's method */ +#define OCI_PTYPE_TYPE_ARG 15 /* user-defined type method's arg */ +#define OCI_PTYPE_TYPE_RESULT 16/* user-defined type method's result */ +#define OCI_PTYPE_SCHEMA 17 /* schema */ +#define OCI_PTYPE_DATABASE 18 /* database */ +#define OCI_PTYPE_RULE 19 /* rule */ +#define OCI_PTYPE_RULE_SET 20 /* rule set */ +#define OCI_PTYPE_EVALUATION_CONTEXT 21 /* evaluation context */ +#define OCI_PTYPE_TABLE_ALIAS 22 /* table alias */ +#define OCI_PTYPE_VARIABLE_TYPE 23 /* variable type */ +#define OCI_PTYPE_NAME_VALUE 24 /* name value pair */ + +/*---------------------------------------------------------------------------*/ + +/*----------------------------- OCI List Types ------------------------------*/ +#define OCI_LTYPE_UNK 0 /* unknown */ +#define OCI_LTYPE_COLUMN 1 /* column list */ +#define OCI_LTYPE_ARG_PROC 2 /* procedure argument list */ +#define OCI_LTYPE_ARG_FUNC 3 /* function argument list */ +#define OCI_LTYPE_SUBPRG 4 /* subprogram list */ +#define OCI_LTYPE_TYPE_ATTR 5 /* type attribute */ +#define OCI_LTYPE_TYPE_METHOD 6 /* type method */ +#define OCI_LTYPE_TYPE_ARG_PROC 7 /* type method w/o result argument list */ +#define OCI_LTYPE_TYPE_ARG_FUNC 8 /* type method w/result argument list */ +#define OCI_LTYPE_SCH_OBJ 9 /* schema object list */ +#define OCI_LTYPE_DB_SCH 10 /* database schema list */ +#define OCI_LTYPE_TYPE_SUBTYPE 11 /* subtype list */ +#define OCI_LTYPE_TABLE_ALIAS 12 /* table alias list */ +#define OCI_LTYPE_VARIABLE_TYPE 13 /* variable type list */ +#define OCI_LTYPE_NAME_VALUE 14 /* name value list */ + +/*---------------------------------------------------------------------------*/ + +/*-------------------------- Memory Cartridge Services ---------------------*/ +#define OCI_MEMORY_CLEARED 1 + +/*-------------------------- Pickler Cartridge Services ---------------------*/ +typedef struct OCIPicklerTdsCtx OCIPicklerTdsCtx; +typedef struct OCIPicklerTds OCIPicklerTds; +typedef struct OCIPicklerImage OCIPicklerImage; +typedef struct OCIPicklerFdo OCIPicklerFdo; +typedef ub4 OCIPicklerTdsElement; + +typedef struct OCIAnyData OCIAnyData; + +typedef struct OCIAnyDataSet OCIAnyDataSet; +typedef struct OCIAnyDataCtx OCIAnyDataCtx; + +/*---------------------------------------------------------------------------*/ + +/*--------------------------- User Callback Constants -----------------------*/ +#define OCI_UCBTYPE_ENTRY 1 /* entry callback */ +#define OCI_UCBTYPE_EXIT 2 /* exit callback */ +#define OCI_UCBTYPE_REPLACE 3 /* replacement callback */ + +/*---------------------------------------------------------------------------*/ + +/*--------------------- NLS service type and constance ----------------------*/ +#define OCI_NLS_DAYNAME1 1 /* Native name for Monday */ +#define OCI_NLS_DAYNAME2 2 /* Native name for Tuesday */ +#define OCI_NLS_DAYNAME3 3 /* Native name for Wednesday */ +#define OCI_NLS_DAYNAME4 4 /* Native name for Thursday */ +#define OCI_NLS_DAYNAME5 5 /* Native name for Friday */ +#define OCI_NLS_DAYNAME6 6 /* Native name for for Saturday */ +#define OCI_NLS_DAYNAME7 7 /* Native name for for Sunday */ +#define OCI_NLS_ABDAYNAME1 8 /* Native abbreviated name for Monday */ +#define OCI_NLS_ABDAYNAME2 9 /* Native abbreviated name for Tuesday */ +#define OCI_NLS_ABDAYNAME3 10 /* Native abbreviated name for Wednesday */ +#define OCI_NLS_ABDAYNAME4 11 /* Native abbreviated name for Thursday */ +#define OCI_NLS_ABDAYNAME5 12 /* Native abbreviated name for Friday */ +#define OCI_NLS_ABDAYNAME6 13 /* Native abbreviated name for for Saturday */ +#define OCI_NLS_ABDAYNAME7 14 /* Native abbreviated name for for Sunday */ +#define OCI_NLS_MONTHNAME1 15 /* Native name for January */ +#define OCI_NLS_MONTHNAME2 16 /* Native name for February */ +#define OCI_NLS_MONTHNAME3 17 /* Native name for March */ +#define OCI_NLS_MONTHNAME4 18 /* Native name for April */ +#define OCI_NLS_MONTHNAME5 19 /* Native name for May */ +#define OCI_NLS_MONTHNAME6 20 /* Native name for June */ +#define OCI_NLS_MONTHNAME7 21 /* Native name for July */ +#define OCI_NLS_MONTHNAME8 22 /* Native name for August */ +#define OCI_NLS_MONTHNAME9 23 /* Native name for September */ +#define OCI_NLS_MONTHNAME10 24 /* Native name for October */ +#define OCI_NLS_MONTHNAME11 25 /* Native name for November */ +#define OCI_NLS_MONTHNAME12 26 /* Native name for December */ +#define OCI_NLS_ABMONTHNAME1 27 /* Native abbreviated name for January */ +#define OCI_NLS_ABMONTHNAME2 28 /* Native abbreviated name for February */ +#define OCI_NLS_ABMONTHNAME3 29 /* Native abbreviated name for March */ +#define OCI_NLS_ABMONTHNAME4 30 /* Native abbreviated name for April */ +#define OCI_NLS_ABMONTHNAME5 31 /* Native abbreviated name for May */ +#define OCI_NLS_ABMONTHNAME6 32 /* Native abbreviated name for June */ +#define OCI_NLS_ABMONTHNAME7 33 /* Native abbreviated name for July */ +#define OCI_NLS_ABMONTHNAME8 34 /* Native abbreviated name for August */ +#define OCI_NLS_ABMONTHNAME9 35 /* Native abbreviated name for September */ +#define OCI_NLS_ABMONTHNAME10 36 /* Native abbreviated name for October */ +#define OCI_NLS_ABMONTHNAME11 37 /* Native abbreviated name for November */ +#define OCI_NLS_ABMONTHNAME12 38 /* Native abbreviated name for December */ +#define OCI_NLS_YES 39 /* Native string for affirmative response */ +#define OCI_NLS_NO 40 /* Native negative response */ +#define OCI_NLS_AM 41 /* Native equivalent string of AM */ +#define OCI_NLS_PM 42 /* Native equivalent string of PM */ +#define OCI_NLS_AD 43 /* Native equivalent string of AD */ +#define OCI_NLS_BC 44 /* Native equivalent string of BC */ +#define OCI_NLS_DECIMAL 45 /* decimal character */ +#define OCI_NLS_GROUP 46 /* group separator */ +#define OCI_NLS_DEBIT 47 /* Native symbol of debit */ +#define OCI_NLS_CREDIT 48 /* Native sumbol of credit */ +#define OCI_NLS_DATEFORMAT 49 /* Oracle date format */ +#define OCI_NLS_INT_CURRENCY 50 /* International currency symbol */ +#define OCI_NLS_LOC_CURRENCY 51 /* Locale currency symbol */ +#define OCI_NLS_LANGUAGE 52 /* Language name */ +#define OCI_NLS_ABLANGUAGE 53 /* Abbreviation for language name */ +#define OCI_NLS_TERRITORY 54 /* Territory name */ +#define OCI_NLS_CHARACTER_SET 55 /* Character set name */ +#define OCI_NLS_LINGUISTIC_NAME 56 /* Linguistic name */ +#define OCI_NLS_CALENDAR 57 /* Calendar name */ +#define OCI_NLS_DUAL_CURRENCY 78 /* Dual currency symbol */ +#define OCI_NLS_WRITINGDIR 79 /* Language writing direction */ +#define OCI_NLS_ABTERRITORY 80 /* Territory Abbreviation */ +#define OCI_NLS_DDATEFORMAT 81 /* Oracle default date format */ +#define OCI_NLS_DTIMEFORMAT 82 /* Oracle default time format */ +#define OCI_NLS_SFDATEFORMAT 83 /* Local string formatted date format */ +#define OCI_NLS_SFTIMEFORMAT 84 /* Local string formatted time format */ +#define OCI_NLS_NUMGROUPING 85 /* Number grouping fields */ +#define OCI_NLS_LISTSEP 86 /* List separator */ +#define OCI_NLS_MONDECIMAL 87 /* Monetary decimal character */ +#define OCI_NLS_MONGROUP 88 /* Monetary group separator */ +#define OCI_NLS_MONGROUPING 89 /* Monetary grouping fields */ +#define OCI_NLS_INT_CURRENCYSEP 90 /* International currency separator */ +#define OCI_NLS_CHARSET_MAXBYTESZ 91 /* Maximum character byte size */ +#define OCI_NLS_CHARSET_FIXEDWIDTH 92 /* Fixed-width charset byte size */ +#define OCI_NLS_CHARSET_ID 93 /* Character set id */ +#define OCI_NLS_NCHARSET_ID 94 /* NCharacter set id */ + +#define OCI_NLS_MAXBUFSZ 100 /* Max buffer size may need for OCINlsGetInfo */ + +#define OCI_NLS_BINARY 0x1 /* for the binary comparison */ +#define OCI_NLS_LINGUISTIC 0x2 /* for linguistic comparison */ +#define OCI_NLS_CASE_INSENSITIVE 0x10 /* for case-insensitive comparison */ + +#define OCI_NLS_UPPERCASE 0x20 /* convert to uppercase */ +#define OCI_NLS_LOWERCASE 0x40 /* convert to lowercase */ + +#define OCI_NLS_CS_IANA_TO_ORA 0 /* Map charset name from IANA to Oracle */ +#define OCI_NLS_CS_ORA_TO_IANA 1 /* Map charset name from Oracle to IANA */ +#define OCI_NLS_LANG_ISO_TO_ORA 2 /* Map language name from ISO to Oracle */ +#define OCI_NLS_LANG_ORA_TO_ISO 3 /* Map language name from Oracle to ISO */ +#define OCI_NLS_TERR_ISO_TO_ORA 4 /* Map territory name from ISO to Oracle*/ +#define OCI_NLS_TERR_ORA_TO_ISO 5 /* Map territory name from Oracle to ISO*/ +#define OCI_NLS_TERR_ISO3_TO_ORA 6 /* Map territory name from 3-letter ISO */ + /* abbreviation to Oracle */ +#define OCI_NLS_TERR_ORA_TO_ISO3 7 /* Map territory name from Oracle to */ + /* 3-letter ISO abbreviation */ +#define OCI_NLS_LOCALE_A2_ISO_TO_ORA 8 + /*Map locale name from A2 ISO to oracle*/ +#define OCI_NLS_LOCALE_A2_ORA_TO_ISO 9 + /*Map locale name from oracle to A2 ISO*/ + +typedef struct OCIMsg OCIMsg; +typedef ub4 OCIWchar; + +#define OCI_XMLTYPE_CREATE_OCISTRING 1 +#define OCI_XMLTYPE_CREATE_CLOB 2 +#define OCI_XMLTYPE_CREATE_BLOB 3 + +/*------------------------- Kerber Authentication Modes ---------------------*/ +#define OCI_KERBCRED_PROXY 1 /* Apply Kerberos Creds for Proxy */ +#define OCI_KERBCRED_CLIENT_IDENTIFIER 2/*Apply Creds for Secure Client ID */ + +/*------------------------- Database Startup Flags --------------------------*/ +#define OCI_DBSTARTUPFLAG_FORCE 0x00000001 /* Abort running instance, start */ +#define OCI_DBSTARTUPFLAG_RESTRICT 0x00000002 /* Restrict access to DBA */ + +/*------------------------- Database Shutdown Modes -------------------------*/ +#define OCI_DBSHUTDOWN_TRANSACTIONAL 1 /* Wait for all the transactions */ +#define OCI_DBSHUTDOWN_TRANSACTIONAL_LOCAL 2 /* Wait for local transactions */ +#define OCI_DBSHUTDOWN_IMMEDIATE 3 /* Terminate and roll back */ +#define OCI_DBSHUTDOWN_ABORT 4 /* Terminate and don't roll back */ +#define OCI_DBSHUTDOWN_FINAL 5 /* Orderly shutdown */ + +/*------------------------- Version information -----------------------------*/ +#define OCI_MAJOR_VERSION 11 /* Major release version */ +#define OCI_MINOR_VERSION 2 /* Minor release version */ + +/*---------------------- OCIIOV structure definitions -----------------------*/ +struct OCIIOV +{ + void *bfp; /* The Pointer to the data buffer */ + ub4 bfl; /* Length of the Data Buffer */ +}; +typedef struct OCIIOV OCIIOV; + +/*--------------------------------------------------------------------------- + PRIVATE TYPES AND CONSTANTS + ---------------------------------------------------------------------------*/ + +/* None */ + +/*--------------------------------------------------------------------------- + PUBLIC FUNCTIONS + ---------------------------------------------------------------------------*/ + +/* see ociap.h or ocikp.h */ + +/*--------------------------------------------------------------------------- + PRIVATE FUNCTIONS + ---------------------------------------------------------------------------*/ + +/* None */ + + +#endif /* OCI_ORACLE */ + + +/* more includes */ + +#ifndef OCI1_ORACLE +#include +#endif + +#ifndef ORO_ORACLE +#include +#endif + +#ifndef ORI_ORACLE +#include +#endif + +#ifndef ORL_ORACLE +#include +#endif + +#ifndef ORT_ORACLE +#include +#endif + +#ifndef OCIEXTP_ORACLE +#include +#endif + +#include +#include + +#ifndef OCIXMLDB_ORACLE +#include +#endif + +#ifndef OCI8DP_ORACLE +#include /* interface definitions for the direct path api */ +#endif + +#ifndef OCIEXTP_ORACLE +#include +#endif + +#ifndef OCIXSTREAM_ORACLE +#include +#endif + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + diff --git a/OCI/include/oci1.h b/OCI/include/oci1.h new file mode 100644 index 0000000..8c59c94 --- /dev/null +++ b/OCI/include/oci1.h @@ -0,0 +1,182 @@ + +/* Copyright (c) 1997, 2005, Oracle. All rights reserved. */ + +/* NOTE: See 'header_template.doc' in the 'doc' dve under the 'forms' + directory for the header file template that includes instructions. +*/ + +/* + NAME + oci1.h - Cartridge Service definitions + + DESCRIPTION + + + RELATED DOCUMENTS + + INSPECTION STATUS + Inspection date: + Inspection status: + Estimated increasing cost defects per page: + Rule sets: + + ACCEPTANCE REVIEW STATUS + Review date: + Review status: + Reviewers: + + PUBLIC FUNCTION(S) + + + PRIVATE FUNCTION(S) + + + EXAMPLES + + NOTES + + + MODIFIED (MM/DD/YY) + mbastawa 09/16/05 - dbhygiene + dmukhin 06/29/05 - ANSI prototypes; miscellaneous cleanup + nramakri 01/16/98 - remove #ifdef NEVER clause + ewaugh 12/18/97 - Turn type wrappers into functions. + skabraha 12/02/97 - Adding data structures & constants for OCIFile + rhwu 12/02/97 - OCI Thread + nramakri 12/15/97 - move to core4 + ewaugh 12/11/97 - add OCIFormat package constants + ssamu 12/10/97 - do not include s.h + nramakri 11/19/97 - add OCIExtract definitions + ssamu 11/14/97 - creation + +*/ + + +#ifndef OCI1_ORACLE +# define OCI1_ORACLE + +# ifndef ORATYPES +# include +# endif + + +/*--------------------------------------------------------------------------- + PUBLIC TYPES AND CONSTANTS + ---------------------------------------------------------------------------*/ + +/* Constants required by the OCIFormat package. */ + +#define OCIFormatUb1(variable) OCIFormatTUb1(), &(variable) +#define OCIFormatUb2(variable) OCIFormatTUb2(), &(variable) +#define OCIFormatUb4(variable) OCIFormatTUb4(), &(variable) +#define OCIFormatUword(variable) OCIFormatTUword(), &(variable) +#define OCIFormatUbig_ora(variable) OCIFormatTUbig_ora(), &(variable) +#define OCIFormatSb1(variable) OCIFormatTSb1(), &(variable) +#define OCIFormatSb2(variable) OCIFormatTSb2(), &(variable) +#define OCIFormatSb4(variable) OCIFormatTSb4(), &(variable) +#define OCIFormatSword(variable) OCIFormatTSword(), &(variable) +#define OCIFormatSbig_ora(variable) OCIFormatTSbig_ora(), &(variable) +#define OCIFormatEb1(variable) OCIFormatTEb1(), &(variable) +#define OCIFormatEb2(variable) OCIFormatTEb2(), &(variable) +#define OCIFormatEb4(variable) OCIFormatTEb4(), &(variable) +#define OCIFormatEword(variable) OCIFormatTEword(), &(variable) +#define OCIFormatChar(variable) OCIFormatTChar(), &(variable) +#define OCIFormatText(variable) OCIFormatTText(), (variable) +#define OCIFormatDouble(variable) OCIFormatTDouble(), &(variable) +#define OCIFormatDvoid(variable) OCIFormatTDvoid(), (variable) +#define OCIFormatEnd OCIFormatTEnd() + +#define OCIFormatDP 6 + + +/*----------------- Public Constants for OCIFile -------------------------*/ + +/* flags for open.*/ +/* flags for mode */ +#define OCI_FILE_READ_ONLY 1 /* open for read only */ +#define OCI_FILE_WRITE_ONLY 2 /* open for write only */ +#define OCI_FILE_READ_WRITE 3 /* open for read & write */ +/* flags for create */ +#define OCI_FILE_EXIST 0 /* the file should exist */ +#define OCI_FILE_CREATE 1 /* create if the file doesn't exist */ +#define OCI_FILE_EXCL 2 /* the file should not exist */ +#define OCI_FILE_TRUNCATE 4 /* create if the file doesn't exist, + else truncate file the file to 0 */ +#define OCI_FILE_APPEND 8 /* open the file in append mode */ + +/* flags for seek */ +#define OCI_FILE_SEEK_BEGINNING 1 /* seek from the beginning of the file */ +#define OCI_FILE_SEEK_CURRENT 2 /* seek from the current position */ +#define OCI_FILE_SEEK_END 3 /* seek from the end of the file */ + +#define OCI_FILE_FORWARD 1 /* seek forward */ +#define OCI_FILE_BACKWARD 2 /* seek backward */ + +/* file type */ +#define OCI_FILE_BIN 0 /* binary file */ +#define OCI_FILE_TEXT 1 /* text file */ +#define OCI_FILE_STDIN 2 /* standard i/p */ +#define OCI_FILE_STDOUT 3 /* standard o/p */ +#define OCI_FILE_STDERR 4 /* standard error */ + +/* Represents an open file */ +typedef struct OCIFileObject OCIFileObject; + + +/*--------------------- OCI Thread Object Definitions------------------------*/ + +/* OCIThread Context */ +typedef struct OCIThreadContext OCIThreadContext; + +/* OCIThread Mutual Exclusion Lock */ +typedef struct OCIThreadMutex OCIThreadMutex; + +/* OCIThread Key for Thread-Specific Data */ +typedef struct OCIThreadKey OCIThreadKey; + +/* OCIThread Thread ID */ +typedef struct OCIThreadId OCIThreadId; + +/* OCIThread Thread Handle */ +typedef struct OCIThreadHandle OCIThreadHandle; + + +/*-------------------- OCI Thread Callback Function Pointers ----------------*/ + +/* OCIThread Key Destructor Function Type */ +typedef void (*OCIThreadKeyDestFunc)( void * ); + + +/* Flags passed into OCIExtractFromXXX routines to direct processing */ +#define OCI_EXTRACT_CASE_SENSITIVE 0x1 /* matching is case sensitive */ +#define OCI_EXTRACT_UNIQUE_ABBREVS 0x2 /* unique abbreviations for keys + are allowed */ +#define OCI_EXTRACT_APPEND_VALUES 0x4 /* if multiple values for a key + exist, this determines if the + new value should be appended + to (or replace) the current + list of values */ + +/* Constants passed into OCIExtractSetKey routine */ +#define OCI_EXTRACT_MULTIPLE 0x8 /* key can accept multiple values */ +#define OCI_EXTRACT_TYPE_BOOLEAN 1 /* key type is boolean */ +#define OCI_EXTRACT_TYPE_STRING 2 /* key type is string */ +#define OCI_EXTRACT_TYPE_INTEGER 3 /* key type is integer */ +#define OCI_EXTRACT_TYPE_OCINUM 4 /* key type is ocinum */ + +/*--------------------------------------------------------------------------- + PRIVATE TYPES AND CONSTANTS + ---------------------------------------------------------------------------*/ + + +/*--------------------------------------------------------------------------- + PUBLIC FUNCTIONS + ---------------------------------------------------------------------------*/ + + +/*--------------------------------------------------------------------------- + PRIVATE FUNCTIONS + ---------------------------------------------------------------------------*/ + + +#endif /* OCI1_ORACLE */ diff --git a/OCI/include/oci8dp.h b/OCI/include/oci8dp.h new file mode 100644 index 0000000..d73258c --- /dev/null +++ b/OCI/include/oci8dp.h @@ -0,0 +1,317 @@ +/* + * + */ + +/* Copyright (c) 1998, 2005, Oracle. All rights reserved. */ + +/* + NAME + oci8dp.h - OCI: Direct Path API interface prototypes. + + DESCRIPTION + Public types, constants, and interfaces to the direct path API. + + RELATED DOCUMENTS + + NOTES + This file is not directly included by the application, this file + is included by "oci.h", which the application should include. + + MODIFIED (MM/DD/YY) + dmukhin 06/29/05 - ANSI prototypes; miscellaneous cleanup + rphillip 02/27/04 - Add OCI_DIRPATH_COL_ERROR + srseshad 03/12/03 - convert oci public api to ansi + msakayed 10/28/02 - Bug #2643907: add OCI_ATTR_DIRPATH_SKIPINDEX_METHOD + cmlim 04/13/01 - remove OCIDirPathStreamToStream - not used by dpapi + cmlim 04/02/01 - OCI_DIRPATH_EXPR_OPQ_SQL_FN to OCI_DIRPATH_EXPR_SQL + ebatbout 01/22/01 - PARTIAL value for OCIDirPathDataSave action parameter + cmlim 07/20/00 - support opaques/sql strings in 8.2 dpapi + cmlim 08/14/00 - support refs in 8.2 dpapi + cmlim 04/17/00 - add defines for OCIDirPathFuncCtx handle & OCI_ATTR_D + whe 09/01/99 - 976457:check __cplusplus for C++ code + abrumm 04/16/99 - dpapi: more attributes + abrumm 02/26/99 - add defines for DataSave action + abrumm 10/04/98 - clen must be a ub4 + abrumm 05/27/98 - add column array flag values + abrumm 05/12/98 - direct path api support + abrumm 03/31/98 - OCI direct path interface support + abrumm 03/18/98 - Creation + +*/ + +#ifndef OCI8DP_ORACLE +# define OCI8DP_ORACLE + +#ifndef ORATYPES +#include +#endif + +#ifndef OCIDFN +#include +#endif + +#ifndef OCI_ORACLE +#include +#endif + + +/*--------------------------------------------------------------------------- + PUBLIC TYPES AND CONSTANTS + ---------------------------------------------------------------------------*/ + +/*----- Handles and descriptors for direct path operations (OCIDirPath*) ----*/ + +typedef struct OCIDirPathCtx OCIDirPathCtx; /* context */ +typedef struct OCIDirPathFuncCtx OCIDirPathFuncCtx; /* function context */ +typedef struct OCIDirPathColArray OCIDirPathColArray; /* column array */ +typedef struct OCIDirPathStream OCIDirPathStream; /* stream */ +typedef struct OCIDirPathDesc OCIDirPathDesc; /* direct path descriptor */ + + /*----- Defines for Direct Path Options -----*/ + + /* values for OCI_ATTR_DIRPATH_MODE attribute */ +#define OCI_DIRPATH_LOAD 1 /* direct path load operation */ +#define OCI_DIRPATH_UNLOAD 2 /* direct path unload operation */ +#define OCI_DIRPATH_CONVERT 3 /* direct path convert only operation */ + + /*----- values for OCI_ATTR_DIRPATH_INDEX_MAINT_METHOD attribute -----*/ +#define OCI_DIRPATH_INDEX_MAINT_SINGLE_ROW 1 + +/* Note that there are two attributes dealing with index maintenance - + * OCI_ATTR_DIRPATH_INDEX_MAINT_METHOD and OCI_ATTR_DIRPATH_SKIPINDEX_METHOD. + * OCI_ATTR_DIRPATH_SKIPINDEX_METHOD exists to isolate the behavior for + * skipping index maintenance since maintenance of unusable indexes is + * orthogonal to that of single row insertion. + * For backwards compatibility we still allow users to specify skip + * methods in OCI_ATTR_DIRPATH_INDEX_MAINT_METHOD so make sure the + * enumerations for the two attributes are distinct. + */ + /*----- values for OCI_ATTR_DIRPATH_SKIPINDEX_METHOD attribute -----*/ +#define OCI_DIRPATH_INDEX_MAINT_SKIP_UNUSABLE 2 +#define OCI_DIRPATH_INDEX_MAINT_DONT_SKIP_UNUSABLE 3 +#define OCI_DIRPATH_INDEX_MAINT_SKIP_ALL 4 + + /* values for OCI_ATTR_STATE attribute of OCIDirPathCtx */ +#define OCI_DIRPATH_NORMAL 1 /* can accept rows, last row complete */ +#define OCI_DIRPATH_PARTIAL 2 /* last row was partial */ +#define OCI_DIRPATH_NOT_PREPARED 3 /* direct path context is not prepared */ + + /*----- values for cflg argument to OCIDirpathColArrayEntrySet -----*/ +#define OCI_DIRPATH_COL_COMPLETE 0 /* column data is complete */ +#define OCI_DIRPATH_COL_NULL 1 /* column is null */ +#define OCI_DIRPATH_COL_PARTIAL 2 /* column data is partial */ +#define OCI_DIRPATH_COL_ERROR 3 /* column error, ignore row */ + /*----- values for action parameter to OCIDirPathDataSave -----*/ +#define OCI_DIRPATH_DATASAVE_SAVEONLY 0 /* data save point only */ +#define OCI_DIRPATH_DATASAVE_FINISH 1 /* execute finishing logic */ +/* save portion of input data (before space error occurred) and finish */ +#define OCI_DIRPATH_DATASAVE_PARTIAL 2 + + /*- OCI_ATTR_DIRPATH_EXPR_TYPE values (describes OCI_ATTR_NAME expr type) -*/ +#define OCI_DIRPATH_EXPR_OBJ_CONSTR 1 /* NAME is an object constructor */ +#define OCI_DIRPATH_EXPR_SQL 2 /* NAME is an opaque or sql function */ +#define OCI_DIRPATH_EXPR_REF_TBLNAME 3 /* NAME is table name if ref is scoped*/ + + +/*--------------------------------------------------------------------------- + PUBLIC FUNCTIONS + ---------------------------------------------------------------------------*/ + +/*------------------------ OCIDirPathCtx Operations -------------------------*/ + +/* + NAME + OCIDirPathAbort - OCI: Abort a direct path operation. + + DESCRIPTION + Aborts a direct path operation. Upon successful completion + the direct path context is no longer valid. + + RETURNS + An OCI error code, Oracle errors are returned via the error handle. + NOTES + */ +sword +OCIDirPathAbort( OCIDirPathCtx *dpctx, OCIError *errhp ); + +/* + NAME + OCIDirPathDataSave - OCI: Execute a data save point. + + DESCRIPTION + Successful return of this function indicates that a data save + point has been executed. + + RETURNS + An OCI error code, Oracle errors are returned via the error handle. + NOTES + */ +sword +OCIDirPathDataSave( OCIDirPathCtx *dpctx, OCIError *errhp, ub4 action ); + +/* + NAME + OCIDirPathFinish - OCI: Finish a direct path operation. + + DESCRIPTION + Finishes a direct path operation. + + RETURNS + An OCI error code, Oracle errors are returned via the error handle. + NOTES + */ +sword +OCIDirPathFinish( OCIDirPathCtx *dpctx, OCIError *errhp ); + +/* + NAME + OCIDirPathFlushRow - OCI: Flush a partial row from the server. + + DESCRIPTION + Flushes a partially loaded row from the server. + + RETURNS + An OCI error code, Oracle errors are returned via the error handle. + NOTES + */ +sword +OCIDirPathFlushRow( OCIDirPathCtx *dpctx, OCIError *errhp ); + +/* + NAME + OCIDirPathPrepare - OCI: Prepare a direct path operation. + + DESCRIPTION + Prepares a table/partition for a direct path operation. + + RETURNS + An OCI error code, Oracle errors are returned via the error handle. + NOTES + */ +sword +OCIDirPathPrepare( OCIDirPathCtx *dpctx, OCISvcCtx *svchp, + OCIError *errhp ); + +/* + NAME + OCIDirPathLoadStream - OCI: Load a direct path stream. + + DESCRIPTION + Load a direct path stream to the object associated with + the direct path context. + + RETURNS + An OCI error code, Oracle errors are returned via the error handle. + NOTES + */ +sword +OCIDirPathLoadStream( OCIDirPathCtx *dpctx, OCIDirPathStream *dpstr, + OCIError *errhp ); + + +/*---------------------- OCIDirPathColArray Operations ----------------------*/ + +/* + NAME + OCIDirPathColArrayEntryGet - OCI: Get column array entry. + + DESCRIPTION + Column array function which is used to get a specified entry in + a column array. + + RETURNS + An OCI error code, Oracle errors are returned via the error handle. + NOTES + */ +sword +OCIDirPathColArrayEntryGet( OCIDirPathColArray *dpca, OCIError *errhp, + ub4 rownum, ub2 colIdx, ub1 **cvalpp, ub4 *clenp, + ub1 *cflgp ); + +/* + NAME + OCIDirPathColArrayEntrySet - OCI: Set column array entry. + + DESCRIPTION + Column array function which is used to set a specified entry in + a column array. + + RETURNS + An OCI error code, Oracle errors are returned via the error handle. + NOTES + */ +sword +OCIDirPathColArrayEntrySet( OCIDirPathColArray *dpca, OCIError *errhp, + ub4 rownum, ub2 colIdx, ub1 *cvalp, ub4 clen, + ub1 cflg ); + +/* + NAME + OCIDirPathColArrayRowGet - OCI: Get column array row pointers. + + DESCRIPTION + Column array function which is used to get the base row pointers + for a specified row in a column array. + To be used in lieu of OCIDirPathColArrayEntryGet() and + OCIDirPathColArrayEntrySet(). + + RETURNS + An OCI error code, Oracle errors are returned via the error handle. + NOTES + */ +sword +OCIDirPathColArrayRowGet( OCIDirPathColArray *dpca, OCIError *errhp, + ub4 rownum, ub1 ***cvalppp, ub4 **clenpp, + ub1 **cflgpp ); + +/* + NAME + OCIDirPathColArrayReset - OCI: Reset Column Array State + + DESCRIPTION + Function which resets the column array state. + + RETURNS + An OCI error code, Oracle errors are returned via the error handle. + NOTES + Resetting the column array state is necessary when piecing in a large + column and an error occurs in the middle of loading the column. + */ +sword +OCIDirPathColArrayReset( OCIDirPathColArray *dpca, OCIError *errhp ); + +/* + NAME + OCIDirPathColArrayToStream - OCI: Convert Column Array to Stream Format. + + DESCRIPTION + Convert from column array format to stream format which is suitable + for loading via OCIDirPathLoadStream(). + + RETURNS + An OCI error code, Oracle errors are returned via the error handle. + NOTES + */ +sword +OCIDirPathColArrayToStream( OCIDirPathColArray *dpca, OCIDirPathCtx *dpctx, + OCIDirPathStream *dpstr, OCIError *errhp, + ub4 rowcnt, ub4 rowoff ); + + + +/*----------------------- OCIDirPathStream Operations -----------------------*/ + +/* + NAME + OCIDirPathStreamReset - OCI: + + DESCRIPTION + + RETURNS + An OCI error code, Oracle errors are returned via the error handle. + NOTES + */ +sword +OCIDirPathStreamReset( OCIDirPathStream *dpstr, OCIError *errhp ); + +#endif /* OCI8DP_ORACLE */ diff --git a/OCI/include/ociap.h b/OCI/include/ociap.h new file mode 100644 index 0000000..4f9aa9b --- /dev/null +++ b/OCI/include/ociap.h @@ -0,0 +1,11122 @@ +/* Copyright (c) 1996, 2008, Oracle. All rights reserved. */ + +/* + NAME + ociap.h + + DESCRIPTION + Oracle Call Interface - Ansi Prototypes + + RELATED DOCUMENTS + + INSPECTION STATUS + Inspection date: + Inspection status: + Estimated increasing cost defects per page: + Rule sets: + + ACCEPTANCE REVIEW STATUS + Review date: + Review status: + Reviewers: + + PUBLIC FUNCTION(S) + OCIAttrGet + OCIAttrSet + OCIBindArrayOfStruct + OCIBindByName + OCIBindByPos + OCIBindDynamic + OCIBindObject + OCIBreak + OCIConnectionPoolCreate + OCISessionPoolCreate + OCISessionGet + OCISessionRelease + OCIDateTimeAssign + OCIDateTimeCheck + OCIDateTimeCompare + OCIDateTimeConvert + OCIDateTimeFromText + OCIDateTimeGetDate + OCIDateTimeGetTime + OCIDateTimeGetTime + OCIDateTimeGetTimeZoneOffset + OCIDateTimeSysTimeStamp + OCIDateTimeIntervalAdd + OCIDateTimeIntervalSub + OCIDateTimeConstruct + OCIDateTimeSubtract + OCIDateTimeToText + OCIDateTimeGetTimeZoneName + OCIDateTimeToArray + OCIDateTimeFromArray + OCIRowidToChar + OCIDefineArrayOfStruct + OCIDefineByPos + OCIDefineDynamic + OCIDefineObject + OCIDescAlloc + OCIDescFree + OCIDescribeAny + OCIEnvCreate + OCIEnvNlsCreate + OCIEnvInit + OCIErrorGet + OCIExtractSetKey + OCIExtractFromFile + OCIIntervalSubtract + OCIIntervalMultiply + OCIIntervalToNumber + OCIIntervalToText + OCIIntervalFromTZ + OCIKerbAttrSet + OCILdaToSvcCtx + OCILobAppend + OCILobAssign + OCILobCharSetForm + OCILobCharSetId + OCILobCopy + OCILobCreateTemporary + OCILobDisableBuffering + OCILobEnableBuffering + OCILobErase + OCILobOpen + OCILobClose + OCILobFileClose + OCILobFileCLoseAll + OCILobFileExists + OCILobFileGetName + OCILobFileIsOpen + OCILobFileOpen + OCILobFileSetName + OCILobFlushBuffer + OCILobFreeTemporary + OCILobGetChunkSize + OCILobGetLength + OCILobIsEqual + OCILobIsTemporary + OCILobLoadFromFile + OCILobLocatorAssign + OCILobLocatorIsInit + OCILobRead + OCILobTrim + OCILobWrite + OCILobWriteAppend + OCILobGetStorageLimit + OCILobGetOptions + OCILobSetOptions + OCILobGetContentType + OCILobSetContentType + OCILogoff + OCILogon + OCILogon2 + OCIMemoryFree + OCIParamGet + OCIParamGet + OCIPasswordChange + OCIReset + OCIResultSetToStmt + OCIServerAttach + OCIServerDetach + OCIServerVersion + OCISessionBegin + OCISessionEnd + OCIStmtExecute + OCIStmtFetch + OCIStmtFetch2 + OCIStmtGetPieceInfo + OCIStmtPrepare + OCIStmtPrepare2 + OCIStmtRelease + OCIStmtSetPieceInfo + OCIFormatString + OCISvcCtxToLda + OCITransCommit + OCITransDetach + OCITransForget + OCITransMultiPrepare + OCITransPrepare + OCITransRollback + OCITransStart + OCIInitialize + OCIEnvCreate + OCIEnvNlsCreate + OCIFEnvCreate + OCIHandleAlloc + OCIDescriptorAlloc + OCIDescriptorFree + OCIArrayDescriptorAlloc + OCIArrayDescriptorFree + OCIEnvInit + OCIServerAttach + OCISessionBegin + OCISessionEnd + OCILogon + OCILogon2 + OCIPasswordChange + OCIStmtPrepare + OCIStmtPrepare2 + OCIStmtRelease + OCIBindByPos + OCIBindByName + OCIBindObject + OCIBindDynamic + OCIBindArrayOfStruct + OCIStmtGetPieceInfo + OCIStmtSetPieceInfo + OCIStmtExecute + OCIDefineByPos + OCIDefineObject + OCIDefineDynamic + OCIRowidToChar + OCIDefineArrayOfStruct + OCIStmtFetch + OCIStmtFetch2 + OCIStmtGetBindInfo + OCIDescribeAny + OCIParamGet + OCIParamSet + OCITransStart + OCITransMultiPrepare + OCIErrorGet + OCILobAppend + OCILobAssign + OCILobCharSetForm + OCILobCharSetId + OCILobCopy + OCILobCreateTemporary + OCILobClose + OCILobDisableBuffering + OCILobEnableBuffering + OCILobErase + OCILobFileClose + OCILobFileExists + OCILobFileGetName + OCILobFileIsOpen + OCILobFileOpen + OCILobFileSetName + OCILobFlushBuffer + OCILobFreeTemporary + OCILobGetChunkSize + OCILobGetLength + OCILobIsEqual + OCILobIsOpen + OCILobIsTemporary + OCILobLoadFromFile + OCILobLocatorAssign + OCILobLocatorIsInit + OCILobOpen + OCILobRead + OCILobTrim + OCILobWrite + OCILobWriteAppend + OCIServerVersion + OCIServerRelease + OCIAttrGet + OCIAttrSet + OCIUserCallbackRegister + OCIUserCallbackGet + OCISharedLibInit + OCIFileExists + OCIFileGetLength + OCIFileOpen + OCIFileRead + OCIFileSeek + OCIFileWrite + OCILobCopy2 + OCILobErase2 + OCILobGetLength2 + OCILobLoadFromFile2 + OCILobRead2 + OCILobArrayRead + OCILobTrim2 + OCILobWrite2 + OCILobArrayWrite + OCILobWriteAppend2 + OCILobGetStorageLimit + OCISecurityOpenWallet + OCISecurityCloseWallet + OCISecurityCreateWallet + OCISecurityDestroyWallet + OCISecurityStorePersona + OCISecurityOpenPersona + OCISecurityClosePersona + OCISecurityRemovePersona + OCISecurityCreatePersona + OCISecuritySetProtection + OCISecurityGetProtection + OCISecurityRemoveIdentity + OCISecurityCreateIdentity + OCISecurityAbortIdentity + OCISecurityFreeIdentity + OCISecurityStoreTrustedIdentity + OCISecuritySign + OCISecuritySignExpansion + OCISecurityVerify + OCISecurityValidate + OCISecuritySignDetached + OCISecuritySignDetExpansion + OCISecurityVerifyDetached + OCISecurity_PKEncrypt + OCISecurityPKEncryptExpansion + OCISecurityPKDecrypt + OCISecurityEncrypt + OCISecurityEncryptExpansion + OCISecurityDecrypt + OCISecurityEnvelope + OCISecurityDeEnvelope + OCISecurityKeyedHash + OCISecurityKeyedHashExpansion + OCISecurityHash + OCISecurityHashExpansion + OCISecuritySeedRandom + OCISecurityRandomBytes + OCISecurityRandomNumber + OCISecurityInitBlock + OCISecurityReuseBlock + OCISecurityPurgeBlock + OCISecuritySetBlock + OCISecurityGetIdentity + OCIAQEnq + OCIAQDeq + OCIAQEnqArray + OCIAQEnqStreaming + OCIAQDeqArray + OCIAQListen + OCIAQListen2 + OCIExtractSetKey + OCIExtractFromFile + OCIExtractToInt + OCIExtractToBool + OCIExtractToStr + OCIExtractToOCINum + OCIExtractFromList + OCIMemoryAlloc + OCIMemoryResize + OCIContextSetValue + OCIContextGetValue + OCIContextClearValue + OCIMemorySetCurrentIDs + OCIPicklerTdsCtxInit + OCIPicklerTdsInit + OCIPicklerTdsCreateElementNumber + OCIPicklerTdsCreateElementChar + OCIPicklerTdsCreateElementVarchar + OCIPicklerTdsCreateElementRaw + OCIPicklerTdsCreateElement + OCIPicklerTdsAddAttr + OCIPicklerTdsGenerate + OCIPicklerTdsGetAttr + OCIPicklerFdoInit + OCIPicklerFdoFree + OCIPicklerImageInit + OCIPicklerImageFree + OCIPicklerImageAddScalar + OCIPicklerImageAddNullScalar + OCIPicklerImageGenerate + OCIPicklerImageGetScalarSize + OCIPicklerImageGetScalar + OCIPicklerImageCollBegin + OCIPicklerImageCollAddScalar + OCIPicklerImageCollEnd + OCIPicklerImageCollBeginScan + OCIPicklerImageCollGetScalarSize + OCIPicklerImageCollGetScalar + OCIAnyDataGetType + OCIAnyDataIsNull + OCIAnyDataConvert + OCIAnyDataBeginCreate + OCIAnyDataAttrSet + OCIAnyDataCollAddElem + OCIAnyDataEndCreate + OCIAnyDataAccess + OCIAnyDataGetCurrAttrNum + OCIAnyDataAttrGet + OCIAnyDataCollGetElem + OCIPicklerTdsCtxInit + OCIPicklerTdsInit + OCIPicklerTdsCreateElementNumber + OCIPicklerTdsCreateElementChar + OCIPicklerTdsCreateElementVarchar + OCIPicklerTdsCreateElementRaw + OCIPicklerTdsCreateElement + OCIPicklerTdsAddAttr + OCIPicklerTdsGenerate + OCIPicklerTdsGetAttr + OCIPicklerFdoInit + OCIPicklerFdoFree + OCIPicklerImageInit + OCIPicklerImageFree + OCIPicklerImageAddScalar + OCIPicklerImageAddNullScalar + OCIPicklerImageGenerate + OCIPicklerImageGetScalarSize + OCIPicklerImageGetScalar + OCIPicklerImageCollBegin + OCIPicklerImageCollAddScalar + OCIPicklerImageCollEnd + OCIPicklerImageCollBeginScan + OCIPicklerImageCollGetScalarSize + OCIPicklerImageCollGetScalar + OCIAnyDataGetType + OCIAnyDataIsNull + OCIAnyDataConvert + OCIAnyDataBeginCreate + OCIAnyDataAttrSet + OCIAnyDataCollAddElem + OCIAnyDataEndCreate + OCIAnyDataAccess + OCIAnyDataGetCurrAttrNum + OCIAnyDataAttrGet + OCIAnyDataCollGetElem + OCIPicklerTdsCtxInit + OCIPicklerTdsInit + OCIPicklerTdsCreateElementNumber + OCIPicklerTdsCreateElementChar + OCIPicklerTdsCreateElementVarchar + OCIPicklerTdsCreateElementRaw + OCIPicklerTdsCreateElement + OCIPicklerTdsAddAttr + OCIPicklerTdsGenerate + OCIPicklerTdsGetAttr + OCIPicklerFdoInit + OCIPicklerFdoFree + OCIPicklerImageInit + OCIPicklerImageFree + OCIPicklerImageAddScalar + OCIPicklerImageAddNullScalar + OCIPicklerImageGenerate + OCIPicklerImageGetScalarSize + OCIPicklerImageGetScalar + OCIPicklerImageCollBegin + OCIPicklerImageCollAddScalar + OCIPicklerImageCollEnd + OCIPicklerImageCollBeginScan + OCIPicklerImageCollGetScalarSize + OCIPicklerImageCollGetScalar + OCIAnyDataGetType + OCIAnyDataIsNull + OCIAnyDataConvert + OCIAnyDataBeginCreate + OCIAnyDataAttrSet + OCIAnyDataCollAddElem + OCIAnyDataEndCreate + OCIAnyDataAccess + OCIAnyDataGetCurrAttrNum + OCIAnyDataAttrGet + OCIAnyDataCollGetElem + OCIAnyDataSetBeginCreate + OCIAnyDataSetDestroy + OCIAnyDataSetAddInstance + OCIAnyDataSetEndCreate + OCIAnyDataSetGetType + OCIAnyDataSetGetCount + OCIAnyDataSetGetInstance + OCIFormatString + OCINlsGetInfo + OCINlsNameMap + OCIMultiByteToWideChar + OCIMultiByteInSizeToWideChar + OCIWideCharToMultiByte + OCIWideCharInSizeToMultiByte + OCIWideCharStrcmp + OCIWideCharStrncmp + OCIWideCharStrcat + *OCIWideCharStrchr + OCIWideCharStrcpy + OCIWideCharStrncat + OCIWideCharStrncpy + *OCIWideCharStrrchr + OCIWideCharStrCaseConversion + OCIMultiByteStrcmp + OCIMultiByteStrncmp + OCIMultiByteStrcat + OCIMultiByteStrcpy + OCIMultiByteStrncat + OCIMultiByteStrncpy + OCIMultiByteStrnDisplayLength + OCIMultiByteStrCaseConversion + OCICharSetToUnicode + OCIUnicodeToCharSet + OCINlsCharSetConvert + OCINlsEnvironmentVariableGet + OCIMessageOpen + OCIMessageGet + OCIThreadMutexInit + OCIThreadMutexDestroy + OCIThreadMutexAcquire + OCIThreadMutexRelease + OCIThreadKeyInit + OCIThreadKeyDestroy + OCIThreadKeyGet + OCIThreadKeySet + OCIThreadIdSet + OCIThreadIdSetNull + OCIThreadIdGet + OCIThreadIdSame + OCIThreadIdNull + OCIThreadHndInit + OCIThreadHndDestroy + OCIThreadCreate + OCIThreadHandleGet + OCIThreadMutexInit + OCIThreadMutexDestroy + OCIThreadMutexAcquire + OCIThreadMutexRelease + OCIThreadKeyInit + OCIThreadKeyDestroy + OCIThreadKeyGet + OCIThreadKeySet + OCIThreadIdSet + OCIThreadIdSame + OCIThreadIdNull + OCIThreadCreate + OCISubscriptionRegister + OCISubscriptionPost + OCISubscriptionUnRegister + OCISubscriptionDisable + OCISubscriptionEnable + OCIDateTimeGetTime + OCIDateTimeGetDate + OCIDateTimeGetTimeZoneOffset + OCIDateTimeConstruct + OCIDateTimeSysTimeStamp + OCIDateTimeAssign + OCIDateTimeToText + OCIDateTimeFromText + OCIDateTimeCompare + OCIDateTimeCheck + OCIDateTimeConvert + OCIDateTimeSubtract + OCIDateTimeIntervalAdd + OCIDateTimeIntervalSub + OCIIntervalSubtract + OCIIntervalAdd + OCIIntervalMultiply + OCIIntervalDivide + OCIIntervalCompare + OCIIntervalFromNumber + OCIIntervalFromText + OCIIntervalToText + OCIIntervalToNumber + OCIIntervalCheck + OCIIntervalAssign + OCIIntervalSetYearMonth + OCIIntervalGetYearMonth + OCIIntervalSetDaySecond + OCIIntervalGetDaySecond + OCIDateTimeToArray + OCIDateTimeFromArray + OCIDateTimeGetTimeZoneName + OCIIntervalFromTZ + OCIConnectionPoolCreate + OCIConnectionPoolDestroy + OCISessionPoolCreate + OCISessionPoolDestroy + OCISessionGet + OCISessionRelease + OCIAppCtxSet + OCIAppCtxClearAll + OCIMemStats + OCIKerbAttrSet + OCIDBStartup + OCIDBShutdown + OCIClientVersion + OCIInitEventHandle + OCIStmtBindByPos + OCIStmtBindByName + + PRIVATE FUNCTION(S) + + EXAMPLES + + NOTES + + MODIFIED (MM/DD/YY) + slynn 03/18/08 - OCILobSet/SetContenttype->OCILobGet/SetContentType + amullick 02/11/08 - add OCILobGet/SetContenttype APIs + schoi 02/27/07 - OCILobGet/SetOptions API change + slynn 07/28/06 - Migrate to new 11g LOB terminology + hqian 05/22/06 - add OCI_SYSASM + slynn 06/21/06 - Add Lob Get Shared Regions Functionality + slynn 05/25/06 - New NG Lob Functionality. + jawilson 05/22/06 - add TDO out parameter for streaming enq callback + aramappa 01/19/06 - Added OCIArrayDescriptorAlloc, + OCIArrayDescriptorFree + jawilson 02/09/06 - add OCIAQEnqStreaming + mxu 03/08/06 - Fix bug 5037807 + srseshad 09/12/05 - stmtcache: callback + mbastawa 09/16/05 - dbhygiene + dmukhin 06/29/05 - ANSI prototypes; miscellaneous cleanup + nbhatt 06/17/04 - merge conflicts + nbhatt 05/24/04 - merge conflicts + weiwang 05/06/04 - add OCIAQListen2 + rvissapr 06/21/04 - add OCIAppCtx API + debanerj 05/17/04 - 13064: LOB array Read and Write + aahluwal 06/02/04 - [OCI Events]: add OCIInitEventHandle + nikeda 05/28/04 - grabtrans 'nikeda_oci_events_copy' + nikeda 05/13/04 - [OCI Events] Rename HACBK->EVTCBK, HACTX->EVTCTX + nikeda 05/10/04 - [OCI Events] code review changes + aahluwal 04/09/04 - [OCI Events]: add OCIHAServerHandleGet + nikeda 03/18/04 - [OCI Events] New Server Handle Callback + dfrumkin 12/04/03 - Add OCIDBStartup, OCIDBShutdown + jciminsk 12/12/03 - merge from RDBMS_MAIN_SOLARIS_031209 + sgollapu 06/26/03 - Change OCIPing prototype + sgollapu 05/05/03 - Add OCIPing + debanerj 01/16/03 - Bug 2753018: Lob Locator parameter for + OCILobGetStorageLimit + rpingte 05/06/04 - add OCIClientVersion + debanerj 08/26/03 - 6003: Lob interface changes + sgollapu 06/23/03 - Add OCIPing + debanerj 01/16/03 - Bug 2753018: Lob Locator parameter for + OCILobGetStorageLimit + tkeefe 02/17/03 - bug-2773794: Add new interface for setting Kerb attrs + ataracha 01/03/03 - Move OCIXMLType functions to ocixml.h + akatti 11/28/02 - [2521361]:add OCIRowidToChar prototype + chliang 10/23/02 - add OCIFetchRowCallback + cparampa 10/13/02 - Fix the prototype of OCIAQListen(ansi prototype) + chliang 10/12/02 - add OCIBindRowCallback + debanerj 09/30/02 - Unlimited size LOB 6003 + thoang 09/25/02 - Add csid to XMLType create functions + thoang 04/19/02 - Add OCIXMLTypeGetNS + aahluwal 08/09/02 - adding OCIAQDeqArray + aahluwal 06/03/02 - bug 2360115 + skabraha 04/16/02 - fix compiler warnings + sichandr 02/12/02 - fix OCIXMLTypeExists + gayyappa 02/01/02 - fix 2210776 : change Dom to DOM + sichandr 10/24/01 - OCISvcCtx for XMLType create routines + schandir 09/14/01 - Add prototypes for Stmt Caching + abande 09/04/01 - Add Prototypes for Session Pooling Methods + stakeda 09/12/01 - add OCINlsCharSetConvert + whe 08/28/01 - add OCIEnvNlsCreate + wzhang 08/22/01 - Add OCINlsCharSetNameToId. + whe 10/05/01 - add prototype for OCIXMLType functions + mdmehta 04/06/01 - Bug 1683763, OCIDateTimeToText: buf_size to ub4* + schandir 12/12/00 - modify the ociconnectionpoolcreate() interface. + porangas 12/04/00 - Forward merge bug#974710 to 9i + rpingte 11/29/00 - Fix bug# 1485795. + gtarora 11/30/00 - fix comment for OCILobIsTemporary + akatti 11/07/00 - [1198379]:add OCIRowidToChar + bpalaval 10/15/00 - Forward merge 892654. + kmohan 09/18/00 - add OCILogon2 + etucker 07/28/00 - add OCIIntervalFromTZ + vjayaram 07/18/00 - add connection pooling changes + etucker 07/13/00 - add dls apis for oci + hmasaki 07/05/00 - fix 1230846: forward merge into 8.2 + mbastawa 06/05/00 - add OCIStmtFetch2 + rxgovind 06/07/00 - update OCIAnyData interfaces + rxgovind 05/04/00 - add OCIAnyDataSet interfaces + rkasamse 05/01/00 - remove attrno from OCIAnyDataAttrGet + rkasamse 03/13/00 - add prototype s for OCCIAnyData + slari 09/01/99 - remove OCIEnvCallback + slari 08/23/99 - add OCIUcb in user callback functions + dsaha 07/07/99 - Add OCIFEnvCreate for forms + vyanaman 06/21/99 - Change OCI DateTime/Interval APIs. + esoyleme 07/01/99 - expose MTS performance enhancements + whe 06/14/99 - bug727872:add CONST to match definitions + kkarun 02/23/99 - Fix OCIDateTime APIs + jiyang 12/07/98 - Add comments for OCI_NLS_DUAL_CURRENCY + aroy 12/01/98 - add OCIEnvCreate + slari 11/23/98 - use ORASTDARG + slari 11/21/98 - replace ellipsis by arglist in OCIUserCallback + thchang 10/20/98 - correct comment on OCILobCreateTemporary + slari 09/08/98 - allow envh to receive error info also in CallbackReg/ + kkarun 09/02/98 - Change const to CONST + aroy 08/04/98 - add OCITerminate calls + nramakri 06/25/98 - remove CONST from some OCIPickler APIs + jiyang 06/22/98 - Fix a lint error + nmallava 06/08/98 - ociistemporary -> envhp + jhasenbe 05/27/98 - Remove definitions for U-Calls (Unicode) + nmallava 05/18/98 - add comments + sgollapu 05/19/98 - Change text to OraText + aroy 04/20/98 - merge forward 8.0.5 -> 8.1.3 + nbhatt 05/14/98 - aq listen call + lchidamb 03/02/98 - Client Notification prototypes + vyanaman 04/19/98 - System Timestamp + kkarun 04/17/98 - Add more Interval functions + vyanaman 04/17/98 - Fix min (proc error) + vyanaman 04/16/98 - Add get/set TZ + kkarun 04/13/98 - Add Datetime prototypes + rkasamse 04/13/98 - change OCIEnv* to dvoid* for context/memory cart serv + rkasamse 04/15/98 - chage pickler cart interface + slari 03/20/98 - change proto of OCIUserCallback + slari 02/17/98 - add OCIUserCallback + jiyang 04/02/98 - Accept both env and user handles for NLS + rkasamse 03/20/98 - remove prototypes for OCIMemoryDuration* functions. + tsaulys 03/20/98 - use environment or session handle + nmallava 04/09/98 - OCILobLocatorAssign + nmallava 04/07/98 - lobgetchunksize and writeappend apis + jhasenbe 04/06/98 - Add new interfaces for Unicode support + nmallava 03/17/98 - add interfaces + nmallava 03/16/98 - add open/close apis + nmallava 03/10/98 - add temporary lobs apis + sgollapu 07/10/97 - Add OCIReset + sgollapu 02/09/98 - OCI non-blocking + nramakri 01/16/98 - remove #ifdef NEVER clause for OCIExtract + rmurthy 01/08/98 - OCIContextGenerateKey: change ub1 to ub4 + ewaugh 12/18/97 - Turn type wrappers into functions. + skabraha 12/02/97 - adding OCIFile functions + rhwu 12/02/97 - add OCI Thread + nramakri 12/15/97 - move to core4 + nramakri 12/11/97 - modify OCIExtract prototype + ewaugh 12/10/97 - add OCIFormat prototypes + nmallava 12/17/97 - Add ilob open and close apis + rkasamse 12/03/97 - Change some of the function names for pickler cartrid + nramakri 11/12/97 - add OCIExtract prototypes + rkasamse 11/21/97 - add prototypes for memory cartridge services and cont + rkasamse 11/03/97 - Add pickler cartridge interfaces. + jiyang 11/11/97 - Add NLS service for cartridge + tanguyen 08/19/97 - + cxcheng 07/30/97 - replace OCISvcCtx with OCISvcCtx + schandra 06/25/97 - AQ OCI interface + bnainani 07/21/97 - add prototypes for Oracle XA extensions + esoyleme 05/13/97 - move failover callback prototype + skmishra 05/06/97 - stdc compiler fixes + skmishra 04/24/97 - C++ Compatibility changes + skotsovo 04/21/97 - make lob parameter names consistent + rwhitman 04/16/97 - Fix LOB prototypes - Olint OCI 8.0.3 + ramkrish 04/15/97 - Add free flag to OCILobFlushBuffer + dchatter 04/10/97 - add nzt.h inclusion + cxcheng 04/09/97 - change objnamp from CONST text* to dvoid* + cxcheng 04/08/97 - fix prototype of OCIDescribeAny() + skotsovo 03/31/97 - remove OCILobLocatorSize + skotsovo 03/27/97 - add OCILobLoadFromFile + bcchang 02/18/97 - Fix syntax error + dchatter 01/13/97 - fix comments on LOB calls + aroy 01/10/97 - remove ocilobfilecreate delete + sgollapu 12/27/96 - Correct OCILogon prototype + dchatter 01/04/97 - comments to describe the functions + sgollapu 11/25/96 - Change OCILobFileIsExistent + schandra 11/18/96 - Remove xa.h include + sgollapu 11/09/96 - Change prototype of OCIDescribeAny + dchatter 10/31/96 - delete CONST from lob write cb fn + dchatter 10/30/96 - more changes + dchatter 10/26/96 - lob/file long name corrections + slari 10/16/96 - delete unused calls + rwessman 10/29/96 - Fixed OCISecurityGetIdentity prototype + bcchang 10/25/96 - Fix syntax error + sgollapu 10/22/96 - Add OCILogon and OCILogoff + rwessman 10/16/96 - Added cryptographic and digital signature functions + sgollapu 10/10/96 - Add ocibdp and ocibdn + rxgovind 10/07/96 - add oci file calls + skotsovo 10/01/96 - move orl lob fnts to oci + skotsovo 09/20/96 - in OCILobGetLength(), remove the 'isnull' parameter. + aroy 08/29/96 - change prototype for Nchar Lob support + dchatter 08/21/96 - OCIResultSetToStmt prototype change + sthakur 08/14/96 - add OCIParamSet + schandra 07/26/96 - TX OCI return values - sb4->sword + aroy 07/17/96 - terminology change: OCILobLocator => OCILobLocator + dchatter 07/01/96 - create ANSI prototypes + dchatter 07/01/96 - Creation + +*/ + + +#ifndef OCIAP_ORACLE +# define OCIAP_ORACLE + +# ifndef ORATYPES +# include +# endif + +#ifndef ORASTDARG +#include +#define ORASTDARG +#endif + +#ifndef OCIDFN +#include +#endif + +#ifndef NZT_ORACLE +#include +#endif /* NZT_ORACLE */ + +#ifndef OCI_ORACLE +#include +#endif + +#ifndef ORT_ORACLE +#include +#endif + + + +/*--------------------------------------------------------------------------- + PUBLIC TYPES AND CONSTANTS + ---------------------------------------------------------------------------*/ + + +/*--------------------------------------------------------------------------- + PRIVATE TYPES AND CONSTANTS + ---------------------------------------------------------------------------*/ + + +/*--------------------------------------------------------------------------- + PUBLIC FUNCTIONS + ---------------------------------------------------------------------------*/ + +/***************************************************************************** + DESCRIPTION +****************************************************************************** +Note: the descriptions of the functions are alphabetically arranged. Please +maintain the arrangement when adding a new function description. The actual +prototypes are below this comment section and donot follow any alphabetical +ordering. + + +--------------------------------OCIAttrGet------------------------------------ + +OCIAttrGet() +Name +OCI Attribute Get +Purpose +This call is used to get a particular attribute of a handle. +Syntax +sword OCIAttrGet ( const void *trgthndlp, + ub4 trghndltyp, + void *attributep, + ub4 *sizep, + ub4 attrtype, + OCIError *errhp ); +Comments +This call is used to get a particular attribute of a handle. +See Appendix B, "Handle Attributes", for a list of handle types and their +readable attributes. +Parameters +trgthndlp (IN) - is the pointer to a handle type. +trghndltyp (IN) - is the handle type. +attributep (OUT) - is a pointer to the storage for an attribute value. The +attribute value is filled in. +sizep (OUT) - is the size of the attribute value. +This can be passed in as NULL for most parameters as the size is well known. +For text* parameters, a pointer to a ub4 must be passed in to get the length +of the string. +attrtype (IN) - is the type of attribute. +errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +Related Functions +OCIAttrSet() + +--------------------------------OCIAttrSet------------------------------------ + + +OCIAttrSet() +Name +OCI Attribute Set +Purpose +This call is used to set a particular attribute of a handle or a descriptor. +Syntax +sword OCIAttrSet ( void *trgthndlp, + ub4 trghndltyp, + void *attributep, + ub4 size, + ub4 attrtype, + OCIError *errhp ); +Comments +This call is used to set a particular attribute of a handle or a descriptor. +See Appendix B for a list of handle types and their writeable attributes. +Parameters +trghndlp (IN/OUT) - the pointer to a handle type whose attribute gets +modified. +trghndltyp (IN/OUT) - is the handle type. +attributep (IN) - a pointer to an attribute value. +The attribute value is copied into the target handle. If the attribute value +is a pointer, then only the pointer is copied, not the contents of the pointer. +size (IN) - is the size of an attribute value. This can be passed in as 0 for +most attributes as the size is already known by the OCI library. For text* +attributes, a ub4 must be passed in set to the length of the string. +attrtype (IN) - the type of attribute being set. +errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +Related Functions +OCIAttrGet() + + + +--------------------------------OCIBindArrayOfStruct-------------------------- + + + +OCIBindArrayOfStruct() +Name +OCI Bind for Array of Structures +Purpose +This call sets up the skip parameters for a static array bind. +Syntax +sword OCIBindArrayOfStruct ( OCIBind *bindp, + OCIError *errhp, + ub4 pvskip, + ub4 indskip, + ub4 alskip, + ub4 rcskip ); +Comments +This call sets up the skip parameters necessary for a static array bind. +This call follows a call to OCIBindByName() or OCIBindByPos(). The bind +handle returned by that initial bind call is used as a parameter for the +OCIBindArrayOfStruct() call. +For information about skip parameters, see the section "Arrays of Structures" +on page 4-16. +Parameters +bindp (IN) - the handle to a bind structure. +errhp (IN) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +pvskip (IN) - skip parameter for the next data value. +indskip (IN) - skip parameter for the next indicator value or structure. +alskip (IN) - skip parameter for the next actual length value. +rcskip (IN) - skip parameter for the next column-level return code value. +Related Functions +OCIAttrGet() + + +--------------------------------OCIBindByName--------------------------------- + +OCIBindByName() +Name +OCI Bind by Name +Purpose +Creates an association between a program variable and a placeholder in a SQL +statement or PL/SQL block. +Syntax +sword OCIBindByName ( + OCIStmt *stmtp, + OCIBind **bindp, + OCIError *errhp, + const OraText *placeholder, + sb4 placeh_len, + void *valuep, + sb4 value_sz, + ub2 dty, + void *indp, + ub2 *alenp, + ub2 *rcodep, + ub4 maxarr_len, + ub4 *curelep, + ub4 mode ); +Description +This call is used to perform a basic bind operation. The bind creates an +association between the address of a program variable and a placeholder in a +SQL statement or PL/SQL block. The bind call also specifies the type of data +which is being bound, and may also indicate the method by which data will be +provided at runtime. +This function also implicitly allocates the bind handle indicated by the bindp +parameter. +Data in an OCI application can be bound to placeholders statically or +dynamically. Binding is static when all the IN bind data and the OUT bind +buffers are well-defined just before the execute. Binding is dynamic when the +IN bind data and the OUT bind buffers are provided by the application on +demand at execute time to the client library. Dynamic binding is indicated by +setting the mode parameter of this call to OCI_DATA_AT_EXEC. +Related Functions: For more information about dynamic binding, see +the section "Runtime Data Allocation and Piecewise Operations" on +page 5-16. +Both OCIBindByName() and OCIBindByPos() take as a parameter a bind handle, +which is implicitly allocated by the bind call A separate bind handle is +allocated for each placeholder the application is binding. +Additional bind calls may be required to specify particular attributes +necessary when binding certain data types or handling input data in certain +ways: +If arrays of structures are being utilized, OCIBindArrayOfStruct() must +be called to set up the necessary skip parameters. +If data is being provided dynamically at runtime, and the application +will be using user-defined callback functions, OCIBindDynamic() must +be called to register the callbacks. +If a named data type is being bound, OCIBindObject() must be called to +specify additional necessary information. +Parameters +stmth (IN/OUT) - the statement handle to the SQL or PL/SQL statement +being processed. +bindp (IN/OUT) - a pointer to a pointer to a bind handle which is implicitly +allocated by this call. The bind handle maintains all the bind information +for this particular input value. The handle is feed implicitly when the +statement handle is deallocated. +errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +placeholder (IN) - the placeholder attributes are specified by name if +ocibindn() is being called. +placeh_len (IN) - the length of the placeholder name specified in placeholder. +valuep (IN/OUT) - a pointer to a data value or an array of data values of the +type specified in the dty parameter. An array of data values can be specified +for mapping into a PL/SQL table or for providing data for SQL multiple-row +operations. When an array of bind values is provided, this is called an array +bind in OCI terms. Additional attributes of the array bind (not bind to a +column of ARRAY type) are set up in OCIBindArrayOfStruct() call. +For a REF, named data type bind, the valuep parameter is used only for IN +bind data. The pointers to OUT buffers are set in the pgvpp parameter +initialized by OCIBindObject(). For named data type and REF binds, the bind +values are unpickled into the Object Cache. The OCI object navigational calls +can then be used to navigate the objects and the refs in the Object Cache. +If the OCI_DATA_AT_EXEC mode is specified in the mode parameter, valuep +is ignored for all data types. OCIBindArrayOfStruct() cannot be used and +OCIBindDynamic() must be invoked to provide callback functions if desired. +value_sz (IN) - the size of a data value. In the case of an array bind, this is +the maximum size of any element possible with the actual sizes being specified +in the alenp parameter. +If the OCI_DATA_AT_EXEC mode is specified, valuesz defines the maximum +size of the data that can be ever provided at runtime for data types other than +named data types or REFs. +dty (IN) - the data type of the value(s) being bound. Named data types +(SQLT_NTY) and REFs (SQLT_REF) are valid only if the application has been +initialized in object mode. For named data types, or REFs, additional calls +must be made with the bind handle to set up the datatype-specific attributes. +indp (IN/OUT) - pointer to an indicator variable or array. For scalar data +types, this is a pointer to sb2 or an array of sb2s. For named data types, +this pointer is ignored and the actual pointer to the indicator structure or +an array of indicator structures is initialized by OCIBindObject(). +Ignored for dynamic binds. +See the section "Indicator Variables" on page 2-43 for more information about +indicator variables. +alenp (IN/OUT) - pointer to array of actual lengths of array elements. Each +element in alenp is the length of the data in the corresponding element in the +bind value array before and after the execute. This parameter is ignored for +dynamic binds. +rcodep (OUT) - pointer to array of column level return codes. This parameter +is ignored for dynamic binds. +maxarr_len (IN) - the maximum possible number of elements of type dty in a +PL/SQL binds. This parameter is not required for non-PL/SQL binds. If +maxarr_len is non-zero, then either OCIBindDynamic() or +OCIBindArrayOfStruct() can be invoked to set up additional bind attributes. +curelep(IN/OUT) - a pointer to the actual number of elements. This parameter +is only required for PL/SQL binds. +mode (IN) - the valid modes for this parameter are: +OCI_DEFAULT. This is default mode. +OCI_DATA_AT_EXEC. When this mode is selected, the value_sz +parameter defines the maximum size of the data that can be ever +provided at runtime. The application must be ready to provide the OCI +library runtime IN data buffers at any time and any number of times. +Runtime data is provided in one of the two ways: +callbacks using a user-defined function which must be registered +with a subsequent call to OCIBindDynamic(). +a polling mechanism using calls supplied by the OCI. This mode +is assumed if no callbacks are defined. +For more information about using the OCI_DATA_AT_EXEC mode, see +the section "Runtime Data Allocation and Piecewise Operations" on +page 5-16. +When the allocated buffers are not required any more, they should be +freed by the client. +Related Functions +OCIBindDynamic(), OCIBindObject(), OCIBindArrayOfStruct(), OCIAttrGet() + + + +-------------------------------OCIBindByPos----------------------------------- + + +OCIBindByPos() +Name +OCI Bind by Position +Purpose +Creates an association between a program variable and a placeholder in a SQL +statement or PL/SQL block. +Syntax +sword OCIBindByPos ( + OCIStmt *stmtp, + OCIBind **bindp, + OCIError *errhp, + ub4 position, + void *valuep, + sb4 value_sz, + ub2 dty, + void *indp, + ub2 *alenp, + ub2 *rcodep, + ub4 maxarr_len, + ub4 *curelep, + ub4 mode); + +Description +This call is used to perform a basic bind operation. The bind creates an +association between the address of a program variable and a placeholder in a +SQL statement or PL/SQL block. The bind call also specifies the type of data +which is being bound, and may also indicate the method by which data will be +provided at runtime. +This function also implicitly allocates the bind handle indicated by the bindp +parameter. +Data in an OCI application can be bound to placeholders statically or +dynamically. Binding is static when all the IN bind data and the OUT bind +buffers are well-defined just before the execute. Binding is dynamic when the +IN bind data and the OUT bind buffers are provided by the application on +demand at execute time to the client library. Dynamic binding is indicated by +setting the mode parameter of this call to OCI_DATA_AT_EXEC. +Related Functions: For more information about dynamic binding, see +the section "Runtime Data Allocation and Piecewise Operations" on +page 5-16 +Both OCIBindByName() and OCIBindByPos() take as a parameter a bind handle, +which is implicitly allocated by the bind call A separate bind handle is +allocated for each placeholder the application is binding. +Additional bind calls may be required to specify particular attributes +necessary when binding certain data types or handling input data in certain +ways: +If arrays of structures are being utilized, OCIBindArrayOfStruct() must +be called to set up the necessary skip parameters. +If data is being provided dynamically at runtime, and the application +will be using user-defined callback functions, OCIBindDynamic() must +be called to register the callbacks. +If a named data type is being bound, OCIBindObject() must be called to +specify additional necessary information. +Parameters +stmth (IN/OUT) - the statement handle to the SQL or PL/SQL statement +being processed. +bindp (IN/OUT) - a pointer to a pointer to a bind handle which is implicitly +allocated by this call. The bind handle maintains all the bind information +for this particular input value. The handle is feed implicitly when the +statement handle is deallocated. +errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +position (IN) - the placeholder attributes are specified by position if +ocibindp() is being called. +valuep (IN/OUT) - a pointer to a data value or an array of data values of the +type specified in the dty parameter. An array of data values can be specified +for mapping into a PL/SQL table or for providing data for SQL multiple-row +operations. When an array of bind values is provided, this is called an array +bind in OCI terms. Additional attributes of the array bind (not bind to a +column of ARRAY type) are set up in OCIBindArrayOfStruct() call. +For a REF, named data type bind, the valuep parameter is used only for IN +bind data. The pointers to OUT buffers are set in the pgvpp parameter +initialized by OCIBindObject(). For named data type and REF binds, the bind +values are unpickled into the Object Cache. The OCI object navigational calls +can then be used to navigate the objects and the refs in the Object Cache. +If the OCI_DATA_AT_EXEC mode is specified in the mode parameter, valuep +is ignored for all data types. OCIBindArrayOfStruct() cannot be used and +OCIBindDynamic() must be invoked to provide callback functions if desired. +value_sz (IN) - the size of a data value. In the case of an array bind, this is +the maximum size of any element possible with the actual sizes being specified +in the alenp parameter. +If the OCI_DATA_AT_EXEC mode is specified, valuesz defines the maximum +size of the data that can be ever provided at runtime for data types other than +named data types or REFs. +dty (IN) - the data type of the value(s) being bound. Named data types +(SQLT_NTY) and REFs (SQLT_REF) are valid only if the application has been +initialized in object mode. For named data types, or REFs, additional calls +must be made with the bind handle to set up the datatype-specific attributes. +indp (IN/OUT) - pointer to an indicator variable or array. For scalar data +types, this is a pointer to sb2 or an array of sb2s. For named data types, +this pointer is ignored and the actual pointer to the indicator structure or +an array of indicator structures is initialized by OCIBindObject(). Ignored +for dynamic binds. +See the section "Indicator Variables" on page 2-43 for more information about +indicator variables. +alenp (IN/OUT) - pointer to array of actual lengths of array elements. Each +element in alenp is the length of the data in the corresponding element in the +bind value array before and after the execute. This parameter is ignored for +dynamic binds. +rcodep (OUT) - pointer to array of column level return codes. This parameter +is ignored for dynamic binds. +maxarr_len (IN) - the maximum possible number of elements of type dty in a +PL/SQL binds. This parameter is not required for non-PL/SQL binds. If +maxarr_len is non-zero, then either OCIBindDynamic() or +OCIBindArrayOfStruct() can be invoked to set up additional bind attributes. +curelep(IN/OUT) - a pointer to the actual number of elements. This parameter +is only required for PL/SQL binds. +mode (IN) - the valid modes for this parameter are: +OCI_DEFAULT. This is default mode. +OCI_DATA_AT_EXEC. When this mode is selected, the value_sz +parameter defines the maximum size of the data that can be ever +provided at runtime. The application must be ready to provide the OCI +library runtime IN data buffers at any time and any number of times. +Runtime data is provided in one of the two ways: +callbacks using a user-defined function which must be registered +with a subsequent call to OCIBindDynamic() . +a polling mechanism using calls supplied by the OCI. This mode +is assumed if no callbacks are defined. +For more information about using the OCI_DATA_AT_EXEC mode, see +the section "Runtime Data Allocation and Piecewise Operations" on +page 5-16. +When the allocated buffers are not required any more, they should be +freed by the client. +Related Functions +OCIBindDynamic(), OCIBindObject(), OCIBindArrayOfStruct(), OCIAttrGet() + + + +-------------------------------OCIBindDynamic--------------------------------- + +OCIBindDynamic() +Name +OCI Bind Dynamic Attributes +Purpose +This call is used to register user callbacks for dynamic data allocation. +Syntax +sword OCIBindDynamic( OCIBind *bindp, + OCIError *errhp, + void *ictxp, + OCICallbackInBind (icbfp)( + void *ictxp, + OCIBind *bindp, + ub4 iter, + ub4 index, + void **bufpp, + ub4 *alenp, + ub1 *piecep, + void **indp ), + void *octxp, + OCICallbackOutBind (ocbfp)( + void *octxp, + OCIBind *bindp, + ub4 iter, + ub4 index, + void **bufp, + ub4 **alenpp, + ub1 *piecep, + void **indpp, + ub2 **rcodepp) ); +Comments +This call is used to register user-defined callback functions for providing +data for an UPDATE or INSERT if OCI_DATA_AT_EXEC mode was specified in a +previous call to OCIBindByName() or OCIBindByPos(). +The callback function pointers must return OCI_CONTINUE if it the call is +successful. Any return code other than OCI_CONTINUE signals that the client +wishes to abort processing immediately. +For more information about the OCI_DATA_AT_EXEC mode, see the section +"Runtime Data Allocation and Piecewise Operations" on page 5-16. +Parameters +bindp (IN/OUT) - a bind handle returned by a call to OCIBindByName() or +OCIBindByPos(). +errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +ictxp (IN) - the context pointer required by the call back function icbfp. +icbfp (IN) - the callback function which returns a pointer to the IN bind +value or piece at run time. The callback takes in the following parameters. +ictxp (IN/OUT) - the context pointer for this callback function. +bindp (IN) - the bind handle passed in to uniquely identify this bind +variable. +iter (IN) - 1-based execute iteration value. +index (IN) - index of the current array, for an array bind. 1 based not +greater than curele parameter of the bind call. +index (IN) - index of the current array, for an array bind. This parameter +is 1-based, and may not be greater than curele parameter of the bind call. +bufpp (OUT) - the pointer to the buffer. +piecep (OUT) - which piece of the bind value. This can be one of the +following values - OCI_ONE_PIECE, OCI_FIRST_PIECE, +OCI_NEXT_PIECE and OCI_LAST_PIECE. +indp (OUT) - contains the indicator value. This is apointer to either an +sb2 value or a pointer to an indicator structure for binding named data +types. +indszp (OUT) - contains the indicator value size. A pointer containing +the size of either an sb2 or an indicator structure pointer. +octxp (IN) - the context pointer required by the callback function ocbfp. +ocbfp (IN) - the callback function which returns a pointer to the OUT bind +value or piece at run time. The callback takes in the following parameters. +octxp (IN/OUT) - the context pointer for this call back function. +bindp (IN) - the bind handle passed in to uniquely identify this bind +variable. +iter (IN) - 1-based execute iteration value. +index (IN) - index of the current array, for an array bind. This parameter +is 1-based, and must not be greater than curele parameter of the bind call. +bufpp (OUT) - a pointer to a buffer to write the bind value/piece. +buflp (OUT) - returns the buffer size. +alenpp (OUT) - a pointer to a storage for OCI to fill in the size of the bind +value/piece after it has been read. +piecep (IN/OUT) - which piece of the bind value. It will be set by the +library to be one of the following values - OCI_ONE_PIECE or +OCI_NEXT_PIECE. The callback function can leave it unchanged or set +it to OCI_FIRST_PIECE or OCI_LAST_PIECE. By default - +OCI_ONE_PIECE. +indpp (OUT) - returns a pointer to contain the indicator value which +either an sb2 value or a pointer to an indicator structure for named data +types. +indszpp (OUT) - returns a pointer to return the size of the indicator +value which is either size of an sb2 or size of an indicator structure. +rcodepp (OUT) - returns a pointer to contains the return code. +Related Functions +OCIAttrGet() + + +---------------------------------OCIBindObject-------------------------------- + + +OCIBindObject() +Name +OCI Bind Object +Purpose +This function sets up additional attributes which are required for a named +data type (object) bind. +Syntax +sword OCIBindObject ( OCIBind *bindp, + OCIError *errhp, + const OCIType *type, + void **pgvpp, + ub4 *pvszsp, + void **indpp, + ub4 *indszp, ); +Comments +This function sets up additional attributes which binding a named data type +or a REF. An error will be returned if this function is called when the OCI +environment has been initialized in non-object mode. +This call takes as a paramter a type descriptor object (TDO) of datatype +OCIType for the named data type being defined. The TDO can be retrieved +with a call to OCITypeByName(). +If the OCI_DATA_AT_EXEC mode was specified in ocibindn() or ocibindp(), the +pointers to the IN buffers are obtained either using the callback icbfp +registered in the OCIBindDynamic() call or by the OCIStmtSetPieceInfo() call. +The buffers are dynamically allocated for the OUT data and the pointers to +these buffers are returned either by calling ocbfp() registered by the +OCIBindDynamic() or by setting the pointer to the buffer in the buffer passed +in by OCIStmtSetPieceInfo() called when OCIStmtExecute() returned +OCI_NEED_DATA. The memory of these client library- allocated buffers must be +freed when not in use anymore by using the OCIObjectFreee() call. +Parameters +bindp ( IN/OUT) - the bind handle returned by the call to OCIBindByName() +or OCIBindByPos(). +errhp ( IN/OUT) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +type ( IN) - points to the TDO which describes the type of the program +variable being bound. Retrieved by calling OCITypeByName(). +pgvpp ( IN/OUT) - points to a pointer to the program variable buffer. For an +array, pgvpp points to an array of pointers. When the bind variable is also an +OUT variable, the OUT Named Data Type value or REF is allocated +(unpickled) in the Object Cache, and a pointer to the value or REF is returned, +At the end of execute, when all OUT values have been received, pgvpp points +to an array of pointer(s) to these newly allocated named data types in the +object cache. +pgvpp is ignored if the OCI_DATA_AT_EXEC mode is set. Then the Named +Data Type buffers are requested at runtime. For static array binds, skip +factors may be specified using the OCIBindArrayOfStruct() call. The skip +factors are used to compute the address of the next pointer to the value, the +indicator structure and their sizes. +pvszsp ( IN/OUT) - points to the size of the program variable. The size of the +named data type is not required on input. For an array, pvszsp is an array of +ub4s. On return, for OUT bind variables, this points to size(s) of the Named +Data Types and REFs received. pvszsp is ignored if the OCI_DATA_AT_EXEC +mode is set. Then the size of the buffer is taken at runtime. +indpp ( IN/OUT) - points to a pointer to the program variable buffer +containing the parallel indicator structure. For an array, points to an array +of pointers. When the bind variable is also an OUT bind variable, memory is +allocated in the object cache, to store the unpickled OUT indicator values. At +the end of the execute when all OUT values have been received, indpp points +to the pointer(s) to these newly allocated indicator structure(s). +indpp is ignored if the OCI_DATA_AT_EXEC mode is set. Then the indicator +is requested at runtime. +indszp ( IN/OUT) - points to the size of the IN indicator structure program +variable. For an array, it is an array of sb2s. On return for OUT bind +variables, this points to size(s) of the received OUT indicator structures. +indszp is ignored if the OCI_DATA_AT_EXEC mode is set. Then the indicator +size is requested at runtime. +Related Functions +OCIAttrGet() + + + +----------------------------------OCIBreak------------------------------------ + + +OCIBreak() +Name +OCI Break +Purpose +This call performs an immediate (asynchronous) abort of any currently +executing OCI function that is associated with a server . +Syntax +sword OCIBreak ( void *hndlp, + OCIError *errhp); +Comments +This call performs an immediate (asynchronous) abort of any currently +executing OCI function that is associated with a server. It is normally used +to stop a long-running OCI call being processed on the server. +This call can take either the service context handle or the server context +handle as a parameter to identify the function to be aborted. +Parameters +hndlp (IN) - the service context handle or the server context handle. +errhp (IN) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +Related Functions + +-----------------------------OCIConnectionPoolCreate -------------------------- +Name: +OCIConnectionPoolCreate + +Purpose: +Creates the connections in the pool + +Syntax: +OCIConnectionPoolCreate (OCIEnv *envhp, OCIError *errhp, OCICPool *poolhp, + OraText **poolName, sb4 *poolNameLen, + const Oratext *dblink, sb4 dblinkLen, + ub4 connMin, ub4 connMax, ub4 connIncr, + const OraText *poolUsername, sb4 poolUserLen, + const OraText *poolPassword, sb4 poolPassLen, + ub4 mode) +Comments: +This call is used to create a connection pool. conn_min connections +to the database are started on calling OCIConnectionPoolCreate. + +Parameters: +envhp (IN/OUT) - A pointer to the environment where the Conencton Pool + is to be created +errhp (IN/OUT) - An error handle which can be passed to OCIErrorGet(). +poolhp (IN/OUT) - An uninitialiazed pool handle. +poolName (OUT) - The connection pool name. +poolNameLen (OUT) - The length of the connection pool name +dblink (IN/OUT) - Specifies the database(server) to connect. This will also + be used as the default pool name. +dblinkLen (IN) - The length of the string pointed to by dblink. +connMin (IN) - Specifies the minimum number of connections in the + Connection Pool at any instant. + connMin number of connections are started when + OCIConnectionPoolCreate() is called. +connMax (IN) - Specifies the maximum number of connections that can be + opened to the database. Once this value is reached, no + more connections are opened. +connIncr (IN) - Allows application to set the next increment for + connections to be opened to the database if the current + number of connections are less than conn_max. +poolUsername (IN/OUT) - Connection pooling requires an implicit proxy + session and this attribute provides a username + for that session. +poolUserLen (IN) - This represents the length of pool_username. +poolPassword (IN/OUT) - The password for the parameter pool_username passed + above. +poolPassLen (IN) - This represents the length of pool_password. + +mode (IN) - The modes supported are OCI_DEFAULT and +OCI_CPOOL_REINITIALIZE + +Related Functions +OCIConnectionPoolDestroy() + +--------------------------------------------------------------------------- + +----------------------------OCIConnectionPoolDestroy------------------------- +Name: +OCIConnectionPoolDestroy + +Purpose: +Terminates the connections in the pool + +Syntax: +OCIConnectionPoolDestroy (OCICPool *poolhp, OCIError *errhp, ub4 mode) + +Comments: +On calling OCIConnectionPoolDestroy, all the open connections in the pool +are closed and the pool is destroyed. + +Parameters: +poolhp (IN/OUT) - An initialiazed pool handle. +errhp (IN/OUT) - An error handle which can be passed to OCIErrorGet(). +mode (IN) - Currently, OCIConnectionPoolDestroy() will support only + the OCI_DEFAULT mode. + +Related Functions: +OCIConnectionPoolCreate() + +----------------------------------------------------------------------------- +----------------------------OCISessionPoolCreate----------------------------- +Name: +OCISessionPoolCreate + +Purpose: +Creates the sessions in the session pool. + +Syntax: +sword OCISessionPoolCreate (OCIEnv *envhp, OCIError *errhp, OCISpool *spoolhp, + OraText **poolName, ub4 *poolNameLen, + const OraText *connStr, ub4 connStrLen, + ub4 sessMin, ub4 sessMax, ub4 sessIncr, + OraText *userid, ub4 useridLen, + OraText *password, ub4 passwordLen, + ub4 mode) + +Comments: +When OCISessionPoolCreate is called, a session pool is initialized for +the associated environment and the database specified by the +connStr parameter. This pool is named uniquely and the name +is returned to the user in the poolname parameter. + +Parameters: +envhp (IN/OUT) - A pointer to the environment handle in which the session + pool needs to be created. +errhp (IN/OUT) - An error handle which can be passed to OCIErrorGet(). +spoolhp (IN/OUT) - A pointer to the session pool handle that is created. +poolName (OUT) - Session pool name returned to the user. +poolNameLen (OUT) - Length of the PoolName +connStr (IN) - The TNS alias of the database to connect to. +connStrLen (IN) - Length of the connStr. +sessMin (IN) - Specifies the minimum number of sessions in the Session Pool. + These are the number of sessions opened in the beginning, if + in Homogeneous mode. Else, the parameter is ignored. +sessMax (IN) - Specifies the maximum number of sessions in the Session Pool. + Once this value is reached, no more sessions are opened, + unless the OCI_ATTR_SPOOL_FORCEGET is set. +userid (IN) - Specifies the userid with which to start up the sessions. +useridLen (IN) - Length of userid. +password (IN) - Specifies the password for the corresponding userid. +passwordLen (IN) - Specifies the length of the password +mode(IN) - May be OCI_DEFAULT, OCI_SPC_SPOOL_REINITIALIZE, or + OCI_SPC_SPOOL_HOMOGENEOUS. + +Returns: +SUCCESS - If pool could be allocated and created successfully. +ERROR - If above conditions could not be met. + +Related Functions: +OCISessionPoolDestroy() +----------------------------------------------------------------------------- +-----------------------------OCISessionPoolDestroy--------------------------- +Name: +OCISessionPoolDestroy + +Purpose: +Terminates all the sessions in the session pool. + +Syntax: +sword OCISessionPoolDestroy (OCISPool *spoolhp, OCIError *errhp, ub4 mode) + +Comments: +spoolhp (IN/OUT) - The pool handle of the session pool to be destroyed. +errhp (IN/OUT) - An error handle which can be passed to OCIErrorGet(). +mode (IN) - Currently only OCI_DEFAULT mode is supported. + +Returns: +SUCCESS - All the sessions could be closed. +ERROR - If the above condition is not met. + +Related Functions: +OCISessionPoolCreate() +----------------------------------------------------------------------------- +-------------------------------OCISessionGet--------------------------------- +Name: +OCISessionGet + +Purpose: +Get a session. This could be from a session pool, connection pool or +a new standalone session. + +Syntax: +sword OCISessionGet(OCIenv *envhp, OCIError *errhp, OCISvcCtx **svchp, + OCIAuthInfo *authhp, + OraText *poolName, ub4 poolName_len, + const OraText *tagInfo, ub4 tagInfo_len, + OraText **retTagInfo, ub4 *retTagInfo_len, + boolean *found, + ub4 mode) + +Comments: +envhp (IN/OUT) - OCI environment handle. +errhp (IN/OUT) - OCI error handle to be passed to OCIErrorGet(). +svchp (IN/OUT) - Address of an OCI service context pointer. This will be + filled with a server and session handle, attached to the + pool. +authhp (IN/OUT) - OCI Authentication Information handle. +poolName (IN) - This indicates the session/connection pool to get the + session/connection from in the OCI_SPOOL/OCI_CPOOL mode. + In the OCI_DEFAULT mode it refers to the connect string. +poolName_len (IN) - length of poolName. +tagInfo (IN) - indicates the tag of the session that the user wants. If the + user wants a default session, he must specify a NULL here. + Only used for Session Pooling. +tagInfo_len (IN) - the length of tagInfo. +retTagInfo (OUT) - This indicates the type of session that is returned to + the user. Only used for Session Pooling. +retTagInfo_len (OUT) - the length of retTagInfo. +found (OUT) - set to true if the user gets a session he had requested, else + set to false. Only used for Session Pooling. +mode (IN) - The supported modes are OCI_DEFAULT, OCI_CRED_PROXY and + OCI_GET_SPOOL_MATCHANY, OCI_SPOOL and OCI_CPOOL. OCI_SPOOL and + OCI_CPOOL are mutually exclusive. + +Returns: +SUCCESS - if a session was successfully returned into svchp. +SUCCESS_WITH_INFO - if a session was successfully returned into svchp and the + total number of sessions > maxsessions. Only valid for + Session Pooling. +ERROR - If a session could not be retrieved. + +Related Functions: +OCISessionRelease() +----------------------------------------------------------------------------- +---------------------------OCISessionRelease--------------------------------- +Name: +OCISessionRelease + +Purpose: +Release the session. + +Syntax: +sword OCISessionRelease ( OCISvcCtx *svchp, OCIError *errhp, + OraText *tag, ub4 tag_len, + ub4 mode); + +Comments: +svchp (IN/OUT) - The service context associated with the session/connection. +errhp (IN/OUT) - OCI error handle to be passed to OCIErrorGet(). +tag (IN) - Only used for Session Pooling. + This parameter will be ignored unless mode OCI_RLS_SPOOL_RETAG is + specified. In this case, the session is labelled with this tag and + returned to the pool. If this is NULL, then the session is untagged. +tag_len (IN) - Length of the tag. This is ignored unless mode + OCI_RLS_SPOOL_RETAG is set. +mode (IN) - The supported modes are OCI_DEFAULT, OCI_RLS_SPOOL_DROPSESS, + OCI_RLS_SPOOL_RETAG. The last 2 are only valid for Session Pooling. + When OCI_RLS_SPOOL_DROPSESS is specified, the session + will be removed from the session pool. If OCI_RLS_SPOOL_RETAG + is set, the tag on the session will be altered. If this mode is + not set, the tag and tag_len parameters will be ignored. + +Returns: +ERROR - If the session could not be released successfully. +SUCCESS - In all other cases. + +Related Functions: +OCISessionGet(). +----------------------------------------------------------------------------- +------------------------------OCIDateTimeAssign -------------------------- +sword OCIDateTimeAssign(void *hndl, OCIError *err, const OCIDateTime *from, + OCIDateTime *to); +NAME: OCIDateTimeAssign - OCIDateTime Assignment +PARAMETERS: +hndl (IN) - Session/Env handle. +err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). +from (IN) - datetime to be assigned +to (OUT) - lhs of assignment +DESCRIPTION: + Performs date assignment. The type of the output will be same as that + of input + +------------------------------OCIDateTimeCheck---------------------------- +sword OCIDateTimeCheck(void *hndl, OCIError *err, const OCIDateTime *date, + ub4 *valid ); +NAME: OCIDateTimeCheck - OCIDateTime CHecK if the given date is valid +PARAMETERS: +hndl (IN) - Session/Env handle. +err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). +date (IN) - date to be checked +valid (OUT) - returns zero for a valid date, otherwise + the ORed combination of all error bits specified below: + Macro name Bit number Error + ---------- ---------- ----- + OCI_DATE_INVALID_DAY 0x1 Bad day + OCI_DATE_DAY_BELOW_VALID 0x2 Bad DAy Low/high bit (1=low) + OCI_DATE_INVALID_MONTH 0x4 Bad MOnth + OCI_DATE_MONTH_BELOW_VALID 0x8 Bad MOnth Low/high bit (1=low) + OCI_DATE_INVALID_YEAR 0x10 Bad YeaR + OCI_DATE_YEAR_BELOW_VALID 0x20 Bad YeaR Low/high bit (1=low) + OCI_DATE_INVALID_HOUR 0x40 Bad HouR + OCI_DATE_HOUR_BELOW_VALID 0x80 Bad HouR Low/high bit (1=low) + OCI_DATE_INVALID_MINUTE 0x100 Bad MiNute + OCI_DATE_MINUTE_BELOW_VALID 0x200 Bad MiNute Low/high bit (1=low) + OCI_DATE_INVALID_SECOND 0x400 Bad SeCond + OCI_DATE_SECOND_BELOW_VALID 0x800 bad second Low/high bit (1=low) + OCI_DATE_DAY_MISSING_FROM_1582 0x1000 Day is one of those "missing" + from 1582 + OCI_DATE_YEAR_ZERO 0x2000 Year may not equal zero + OCI_DATE_INVALID_TIMEZONE 0x4000 Bad Timezone + OCI_DATE_INVALID_FORMAT 0x8000 Bad date format input + + So, for example, if the date passed in was 2/0/1990 25:61:10 in + (month/day/year hours:minutes:seconds format), the error returned + would be OCI_DATE_INVALID_DAY | OCI_DATE_DAY_BELOW_VALID | + OCI_DATE_INVALID_HOUR | OCI_DATE_INVALID_MINUTE + +DESCRIPTION: + Check if the given date is valid. +RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + 'date' and 'valid' pointers are NULL pointers + +------------------------------- OCIDateTimeCompare---------------------------- +sword OCIDateTimeCompare(void *hndl, OCIError *err, const OCIDateTime *date1, + const OCIDateTime *date2, sword *result ); +NAME: OCIDateTimeCompare - OCIDateTime CoMPare dates +PARAMETERS: +hndl (IN) - Session/Env handle. +err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). +date1, date2 (IN) - dates to be compared +result (OUT) - comparison result, 0 if equal, -1 if date1 < date2, + 1 if date1 > date2 +DESCRIPTION: +The function OCIDateCompare compares two dates. It returns -1 if +date1 is smaller than date2, 0 if they are equal, and 1 if date1 is +greater than date2. +RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + invalid date + input dates are not mutually comparable + +------------------------------OCIDateTimeConvert---------------------- +sword OCIDateTimeConvert(void *hndl, OCIError *err, OCIDateTime *indate, + OCIDateTime *outdate); +NAME: OCIDateTimeConvert - Conversion between different DATETIME types +PARAMETERS: +hndl (IN) - Session/Env handle. +err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). +indate (IN) - pointer to input date +outdate (OUT) - pointer to output datetime +DESCRIPTION: Converts one datetime type to another. The result type is + the type of the 'outdate' descriptor. +RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + conversion not possible. + +---------------------------- OCIDateTimeFromText----------------------- +sword OCIDateTimeFromText(void *hndl, OCIError *err, const OraText *date_str, + size_t d_str_length, const OraText *fmt, ub1 fmt_length, + const OraText *lang_name, size_t lang_length, OCIDateTime *date ); +NAME: OCIDateTimeFromText - OCIDateTime convert String FROM Date +PARAMETERS: +hndl (IN) - Session/Env handle. If Session Handle is passed, the + conversion takes place in session NLS_LANGUAGE and + session NLS_CALENDAR, otherwise the default is used. +err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). +date_str (IN) - input string to be converted to Oracle date +d_str_length (IN) - size of the input string, if the length is -1 + then 'date_str' is treated as a null terminated string +fmt (IN) - conversion format; if 'fmt' is a null pointer, then + the string is expected to be in the default format for + the datetime type. +fmt_length (IN) - length of the 'fmt' parameter +lang_name (IN) - language in which the names and abbreviations of + days and months are specified, if null i.e. (OraText *)0, + the default language of session is used, +lang_length (IN) - length of the 'lang_name' parameter +date (OUT) - given string converted to date +DESCRIPTION: + Converts the given string to Oracle datetime type set in the + OCIDateTime descriptor according to the specified format. Refer to + "TO_DATE" conversion function described in "Oracle SQL Language + Reference Manual" for a description of format. +RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + invalid format + unknown language + invalid input string + +--------------------------- OCIDateTimeGetDate------------------------- +sword OCIDateTimeGetDate(void *hndl, OCIError *err, const OCIDateTime *date, + sb2 *year, ub1 *month, ub1 *day ); +NAME: OCIDateTimeGetDate - OCIDateTime Get Date (year, month, day) + portion of DATETIME. +PARAMETERS: +hndl (IN) - Session/Env handle. +err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). +datetime (IN) - Pointer to OCIDateTime +year (OUT) - year value +month (OUT) - month value +day (OUT) - day value + +--------------------------- OCIDateTimeGetTime ------------------------ +sword OCIDateTimeGetTime(void *hndl, OCIError *err, OCIDateTime *datetime, + ub1 *hour, ub1 *minute, ub1 *sec, ub4 *fsec); +NAME: OCIDateTimeGetTime - OCIDateTime Get Time (hour, min, second, + fractional second) of DATETIME. +PARAMETERS: +hndl (IN) - Session/Env handle. +err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). +datetime (IN) - Pointer to OCIDateTime +hour (OUT) - hour value +minute (OUT) - minute value +sec (OUT) - second value +fsec (OUT) - Fractional Second value + +--------------------------- OCIDateTimeGetTimeZoneOffset ---------------------- +sword OCIDateTimeGetTimeZoneOffset(void *hndl,OCIError *err,const + OCIDateTime *datetime,sb1 *hour,sb1 *minute); + +NAME: OCIDateTimeGetTimeZoneOffset - OCIDateTime Get TimeZone (hour, minute) + portion of DATETIME. +PARAMETERS: +hndl (IN) - Session/Env handle. +err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). +datetime (IN) - Pointer to OCIDateTime +hour (OUT) - TimeZone Hour value +minute (OUT) - TimeZone Minute value + +--------------------------- OCIDateTimeSysTimeStamp--------------------- +sword OCIDateTimeSysTimeStamp(void *hndl, OCIError *err, + OCIDateTime *sys_date ); + +NAME: OCIDateTimeSysTimeStamp - Returns system date/time as a TimeStamp with + timezone +PARAMETERS: +hndl (IN) - Session/Env handle. +err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). +sys_date (OUT) - Pointer to output timestamp + +DESCRIPTION: + Gets the system current date and time as a timestamp with timezone +RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + + +------------------------------OCIDateTimeIntervalAdd---------------------- +sword OCIDateTimeIntervalAdd(void *hndl, OCIError *err, OCIDateTime *datetime, + OCIInterval *inter, OCIDateTime *outdatetime); +NAME: OCIDateTimeIntervalAdd - Adds an interval to datetime +PARAMETERS: +hndl (IN) - Session/Env handle. +err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). +datetime (IN) - pointer to input datetime +inter (IN) - pointer to interval +outdatetime (IN) - pointer to output datetime. The output datetime + will be of same type as input datetime +DESCRIPTION: + Adds an interval to a datetime to produce a resulting datetime +RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if: + resulting date is before Jan 1, -4713 + resulting date is after Dec 31, 9999 + +------------------------------OCIDateTimeIntervalSub---------------------- +sword OCIDateTimeIntervalSub(void *hndl, OCIError *err, OCIDateTime *datetime, + OCIInterval *inter, OCIDateTime *outdatetime); +NAME: OCIDateTimeIntervalSub - Subtracts an interval from a datetime +PARAMETERS: +hndl (IN) - Session/Env handle. +err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). +datetime (IN) - pointer to input datetime +inter (IN) - pointer to interval +outdatetime (IN) - pointer to output datetime. The output datetime + will be of same type as input datetime +DESCRIPTION: + Subtracts an interval from a datetime and stores the result in a + datetime +RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if: + resulting date is before Jan 1, -4713 + resulting date is after Dec 31, 9999 + +--------------------------- OCIDateTimeConstruct------------------------- +sword OCIDateTimeConstruct(void *hndl,OCIError *err,OCIDateTime *datetime, + sb2 year,ub1 month,ub1 day,ub1 hour,ub1 min,ub1 sec,ub4 fsec, + OraText *timezone,size_t timezone_length); + +NAME: OCIDateTimeConstruct - Construct an OCIDateTime. Only the relevant + fields for the OCIDateTime descriptor types are used. +PARAMETERS: + hndl (IN) - Session/Env handle. + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + datetime (IN) - Pointer to OCIDateTime + year (IN) - year value + month (IN) - month value + day (IN) - day value + hour (IN) - hour value + min (IN) - minute value + sec (IN) - second value + fsec (IN) - Fractional Second value + timezone (IN) - Timezone string + timezone_length(IN) - Length of timezone string + +DESCRIPTION: + Constructs a DateTime descriptor. The type of the datetime is the + type of the OCIDateTime descriptor. Only the relevant fields based + on the type are used. For Types with timezone, the date and time + fields are assumed to be in the local time of the specified timezone. + If timezone is not specified, then session default timezone is + assumed. +RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_ERROR if datetime is not valid. + +------------------------------OCIDateTimeSubtract----------------------- +sword OCIDateTimeSubtract(void *hndl, OCIError *err, OCIDateTime *indate1, + OCIDateTime *indate2, OCIInterval *inter); +NAME: OCIDateTimeSubtract - subtracts two datetimes to return an interval +PARAMETERS: +hndl (IN) - Session/Env handle. +err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). +indate1(IN) - pointer to subtrahend +indate2(IN) - pointer to minuend +inter (OUT) - pointer to output interval +DESCRIPTION: + Takes two datetimes as input and stores their difference in an + interval. The type of the interval is the type of the 'inter' + descriptor. +RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + datetimes are not comparable. + +--------------------------- OCIDateTimeToText-------------------------- +sword OCIDateTimeToText(void *hndl, OCIError *err, const OCIDateTime *date, + const OraText *fmt, ub1 fmt_length, ub1 fsprec, + const OraText *lang_name, size_t lang_length, + ub4 *buf_size, OraText *buf ); +NAME: OCIDateTimeToText - OCIDateTime convert date TO String +PARAMETERS: +hndl (IN) - Session/Env handle. If Session Handle is passed, the + conversion takes place in session NLS_LANGUAGE and + session NLS_CALENDAR, otherwise the default is used. +err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). +date (IN) - Oracle datetime to be converted +fmt (IN) - conversion format, if null string pointer (OraText*)0, then + the date is converted to a character string in the + default format for that type. +fmt_length (IN) - length of the 'fmt' parameter +fsprec (IN) - specifies the fractional second precision in which the + fractional seconds is returned. +lang_name (IN) - specifies the language in which the names and + abbreviations of months and days are returned; + default language of session is used if 'lang_name' + is null i.e. (OraText *)0 +lang_length (IN) - length of the 'nls_params' parameter +buf_size (IN/OUT) - size of the buffer; size of the resulting string + is returned via this parameter +buf (OUT) - buffer into which the converted string is placed +DESCRIPTION: + Converts the given date to a string according to the specified format. + Refer to "TO_DATE" conversion function described in + "Oracle SQL Language Reference Manual" for a description of format + and NLS arguments. The converted null-terminated date string is + stored in the buffer 'buf'. +RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + buffer too small + invalid format + unknown language + overflow error + +----------------------------OCIDateTimeGetTimeZoneName------------------------ +sword OCIDateTimeGetTimeZoneName(void *hndl, + OCIError *err, + const OCIDateTime *datetime, + ub1 *buf, + ub4 *buflen); +NAME OCIDateTimeGetTimeZoneName - OCI DateTime Get the Time Zone Name +PARAMETERS: +hndl (IN) - Session/Env handle. +err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). +datetime (IN) - Pointer to an OCIDateTime. +buf (OUT) - User allocated storage for name string. +buflen (IN/OUT) - length of buf on input, length of name on out +DESCRIPTION: + Returns either the timezone region name or the absolute hour and minute + offset. If the DateTime was created with a region id then the region + name will be returned in the buf. If the region id is zero, then the + hour and minute offset is returned as "[-]HH:MM". +RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + buffer too small + error retrieving timezone data + invalid region + invalid LdiDateTime type + +---------------------------------OCIDateTimeToArray---------------------------- +sword OCIDateTimeToArray(void *hndl, + OCIError *err, + const OCIDateTime *datetime, + const OCIInterval *reftz, + ub1 *outarray, + ub4 *len + ub1 *fsprec); +NAME OCIDateTimeToArray - OCI DateTime convert To Array format +PARAMETERS: +hndl (IN) - Session/Env handle. +err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). +datetime (IN) - Pointer to OCIDateTime to be converted. +outarray (OUT) - Result array storage +len (OUT) - pointer to length of outarray. +fsprec (IN) - Number of fractional seconds digits. +DESCRIPTION: + Returns an array representing the input DateTime descriptor. +RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + buffer too small + error retrieving timezone data + invalid region + invalid LdiDateTime type + +--------------------------------OCIDateTimeFromArray--------------------------- +sword OCIDateTimeFromArray(void *hndl, + OCIError *err, + ub1 *inarray, + ub4 len + ub1 type + OCIDateTime *datetime, + OCIInterval *reftz, + ub1 fsprec); +NAME OCIDateTimeFromArray - OCI DateTime convert From Array format +PARAMETERS: +hndl (IN) - Session/Env handle. +err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). +inarray (IN) - Pointer to input array representtion of DateTime +len (IN) - len of inarray. +type (IN) - One of SQLT_DATE, SQLT_TIME, SQLT_TIME_TZ, SQLT_TIMESTAMP, + SQLT_TIMESTAMP_TZ, or SQLT_TIMESTAMP_LTZ. +datetime (OUT) - Pointer to the result OCIDateTime. +reftz (IN) - timezone interval used with SQLT_TIMESTAMP_LTZ. +fsprec (IN) - fractionl seconds digits of precision (0-9). +DESCRIPTION: + Returns a pointer to an OCIDateTime of type type converted from + the inarray. +RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + buffer too small + error retrieving timezone data + invalid region + invalid LdiDateTime type + +----------------------------------OCIRowidToChar----------------------------- +Name +OCIRowidToChar + +Purpose +Converts physical/logical (universal) ROWID to chracter extended (Base 64) +representation into user provided buffer outbfp of length outbflp. After +execution outbflp contains amount of bytes converted.In case of truncation +error, outbflp contains required size to make this conversion successful +and returns ORA-1405. + +Syntax +sword OCIRowidToChar( OCIRowid *rowidDesc, + OraText *outbfp, + ub2 *outbflp, + OCIError *errhp) + +Comments +After this conversion, ROWID in character format can be bound using +OCIBindByPos or OCIBindByName call and used to query a row at a +desired ROWID. + +Parameters +rowidDesc (IN) - rowid DESCriptor which is allocated from OCIDescritorAlloc + and populated by a prior SQL statement execution +outbfp (OUT) - pointer to the buffer where converted rowid in character + representation is stored after successful execution. +outbflp (IN/OUT) - pointer to output buffer length variable. + Before execution (IN mode) *outbflp contains the size of + outbfp, after execution (OUT mode) *outbflp contains amount + of bytes converted. In an event of truncation during + conversion *outbflp contains the required length to make + conversion successful. +errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for + diagnostic information in the event of an error. + +------------------------------OCIDefineArrayOfStruct-------------------------- + + +OCIDefineArrayOfStruct() +Name +OCI Define for Array of Structures +Purpose +This call specifies additional attributes necessary for a static array define. +Syntax +sword OCIDefineArrayOfStruct ( OCIDefine *defnp, + OCIError *errhp, + ub4 pvskip, + ub4 indskip, + ub4 rlskip, + ub4 rcskip ); +Comments +This call specifies additional attributes necessary for an array define, +used in an array of structures (multi-row, multi-column) fetch. +For more information about skip parameters, see the section "Skip Parameters" +on page 4-17. +Parameters +defnp (IN) - the handle to the define structure which was returned by a call +to OCIDefineByPos(). +errhp (IN) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +pvskip (IN) - skip parameter for the next data value. +indskip (IN) - skip parameter for the next indicator location. +rlskip (IN) - skip parameter for the next return length value. +rcskip (IN) - skip parameter for the next return code. +Related Functions +OCIAttrGet() + + + + + +OCIDefineByPos() +Name +OCI Define By Position +Purpose +Associates an item in a select-list with the type and output data buffer. +Syntax +sb4 OCIDefineByPos ( + OCIStmt *stmtp, + OCIDefine **defnp, + OCIError *errhp, + ub4 position, + void *valuep, + sb4 value_sz, + ub2 dty, + void *indp, + ub2 *rlenp, + ub2 *rcodep, + ub4 mode ); +Comments +This call defines an output buffer which will receive data retreived from +Oracle. The define is a local step which is necessary when a SELECT statement +returns data to your OCI application. +This call also implicitly allocates the define handle for the select-list item. +Defining attributes of a column for a fetch is done in one or more calls. The +first call is to OCIDefineByPos(), which defines the minimal attributes +required to specify the fetch. +This call takes as a parameter a define handle, which must have been +previously allocated with a call to OCIHandleAlloc(). +Following the call to OCIDefineByPos() additional define calls may be +necessary for certain data types or fetch modes: +A call to OCIDefineArrayOfStruct() is necessary to set up skip parameters +for an array fetch of multiple columns. +A call to OCIDefineObject() is necessary to set up the appropriate +attributes of a named data type fetch. In this case the data buffer pointer +in ocidefn() is ignored. +Both OCIDefineArrayOfStruct() and OCIDefineObject() must be called +after ocidefn() in order to fetch multiple rows with a column of named +data types. +For a LOB define, the buffer pointer must be a lob locator of type +OCILobLocator , allocated by the OCIDescAlloc() call. LOB locators, and not +LOB values, are always returned for a LOB column. LOB values can then be +fetched using OCI LOB calls on the fetched locator. +For NCHAR (fixed and varying length), the buffer pointer must point to an +array of bytes sufficient for holding the required NCHAR characters. +Nested table columns are defined and fetched like any other named data type. +If the mode parameter is this call is set to OCI_DYNAMIC_FETCH, the client +application can fetch data dynamically at runtime. +Runtime data can be provided in one of two ways: +callbacks using a user-defined function which must be registered with a +subsequent call to OCIDefineDynamic(). When the client library needs a +buffer to return the fetched data, the callback will be invoked and the +runtime buffers provided will return a piece or the whole data. +a polling mechanism using calls supplied by the OCI. This mode is +assumed if no callbacks are defined. In this case, the fetch call returns the +OCI_NEED_DATA error code, and a piecewise polling method is used +to provide the data. +Related Functions: For more information about using the +OCI_DYNAMIC_FETCH mode, see the section "Runtime Data +Allocation and Piecewise Operations" on page 5-16 of Volume 1.. +For more information about the define step, see the section "Defining" +on page 2-30. +Parameters +stmtp (IN) - a handle to the requested SQL query operation. +defnp (IN/OUT) - a pointer to a pointer to a define handle which is implicitly +allocated by this call. This handle is used to store the define information +for this column. +errhp (IN) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +position (IN) - the position of this value in the select list. Positions are +1-based and are numbered from left to right. For example, in the SELECT +statement +SELECT empno, ssn, mgrno FROM employees; +empno is at position 1, ssn is at position 2, and mgrno is at position 3. +valuep (IN/OUT) - a pointer to a buffer or an array of buffers of the type +specified in the dty parameter. A number of buffers can be specified when +results for more than one row are desired in a single fetch call. +value_sz (IN) - the size of each valuep buffer in bytes. If the data is stored +internally in VARCHAR2 format, the number of characters desired, if different +from the buffer size in bytes, may be additionally specified by the using +OCIAttrSet(). +In an NLS conversion environment, a truncation error will be generated if the +number of bytes specified is insufficient to handle the number of characters +desired. +dty (IN) - the data type. Named data type (SQLT_NTY) and REF (SQLT_REF) +are valid only if the environment has been intialized with in object mode. +indp - pointer to an indicator variable or array. For scalar data types, +pointer to sb2 or an array of sb2s. Ignored for named data types. For named +data types, a pointer to a named data type indicator structure or an array of +named data type indicator structures is associated by a subsequent +OCIDefineObject() call. +See the section "Indicator Variables" on page 2-43 for more information about +indicator variables. +rlenp (IN/OUT) - pointer to array of length of data fetched. Each element in +rlenp is the length of the data in the corresponding element in the row after +the fetch. +rcodep (OUT) - pointer to array of column-level return codes +mode (IN) - the valid modes are: +OCI_DEFAULT. This is the default mode. +OCI_DYNAMIC_FETCH. For applications requiring dynamically +allocated data at the time of fetch, this mode must be used. The user may +additionally call OCIDefineDynamic() to set up a callback function that +will be invoked to receive the dynamically allocated buffers and to set +up the memory allocate/free callbacks and the context for the callbacks. +valuep and value_sz are ignored in this mode. +Related Functions +OCIDefineArrayOfStruct(), OCIDefineDynamic(), OCIDefineObject() + + + + +OCIDefineDynamic() +Name +OCI Define Dynamic Fetch Attributes +Purpose +This call is used to set the additional attributes required if the +OCI_DYNAMIC_FETCH mode was selected in OCIDefineByPos(). +Syntax +sword OCIDefineDynamic( OCIDefine *defnp, + OCIError *errhp, + void *octxp, + OCICallbackDefine (ocbfp)( + void *octxp, + OCIDefine *defnp, + ub4 iter, + void **bufpp, + ub4 **alenpp, + ub1 *piecep, + void **indpp, + ub2 **rcodep) ); +Comments +This call is used to set the additional attributes required if the +OCI_DYNAMIC_FETCH mode has been selected in a call to +OCIDefineByPos(). +When the OCI_DYNAMIC_FETCH mode is selected, buffers will be +dynamically allocated for REF, and named data type, values to receive the +data. The pointers to these buffers will be returned. +If OCI_DYNAMIC_FETCH mode was selected, and the call to +OCIDefineDynamic() is skipped, then the application can fetch data piecewise +using OCI calls. +For more information about OCI_DYNAMIC_FETCH mode, see the section +"Runtime Data Allocation and Piecewise Operations" on page 5-16. +Parameters +defnp (IN/OUT) - the handle to a define structure returned by a call to +OCIDefineByPos(). +errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +octxp (IN) - points to a context for the callback function. +ocbfp (IN) - points to a callback function. This is invoked at runtime to get +a pointer to the buffer into which the fetched data or a piece of it will be +retreived. The callback also specifies the indicator, the return code and the +lengths of the data piece and indicator. The callback has the following +parameters: +octxp (IN) - a context pointer passed as an argument to all the callback +functions. +defnp (IN) - the define handle. +iter (IN) - which row of this current fetch. +bufpp (OUT) - returns a pointer to a buffer to store the column value, ie. +*bufp points to some appropriate storage for the column value. +alenpp (OUT) - returns a pointer to the length of the buffer. *alenpp +contains the size of the buffer after return from callback. Gets set to +actual data size after fetch. +piecep (IN/OUT) - returns a piece value, as follows: +The IN value can be OCI_ONE_PIECE, OCI_FIRST_PIECE or +OCI_NEXT_PIECE. +The OUT value can be OCI_ONE_PIECE if the IN value was +OCI_ONE_PIECE. +The OUT value can be OCI_ONE_PIECE or OCI_FIRST_PIECE if +the IN value was OCI_FIRST_PIECE. +The OUT value can only be OCI_NEXT_PIECE or +OCI_LAST_PIECE if the IN value was OCI_NEXT_PIECE. +indpp (IN) - indicator variable pointer +rcodep (IN) - return code variable pointer +Related Functions +OCIAttrGet() +OCIDefineObject() + + + + +OCIDefineObject() +Name +OCI Define Named Data Type attributes +Purpose +Sets up additional attributes necessary for a Named Data Type define. +Syntax +sword OCIDefineObject ( OCIDefine *defnp, + OCIError *errhp, + const OCIType *type, + void **pgvpp, + ub4 *pvszsp, + void **indpp, + ub4 *indszp ); +Comments +This call sets up additional attributes necessary for a Named Data Type define. +An error will be returned if this function is called when the OCI environment +has been initialized in non-Object mode. +This call takes as a paramter a type descriptor object (TDO) of datatype +OCIType for the named data type being defined. The TDO can be retrieved +with a call to OCITypeByName(). +See the description of OCIInitialize() on page 13 - 43 for more information +about initializing the OCI process environment. +Parameters +defnp (IN/OUT) - a define handle previously allocated in a call to +OCIDefineByPos(). +errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +type (IN, optional) - points to the Type Descriptor Object (TDO) which +describes the type of the program variable. Only used for program variables +of type SQLT_NTY. This parameter is optional, and may be passed as NULL +if it is not being used. +pgvpp (IN/OUT) - points to a pointer to a program variable buffer. For an +array, pgvpp points to an array of pointers. Memory for the fetched named data +type instance(s) is dynamically allocated in the object cache. At the end of +the fetch when all the values have been received, pgvpp points to the +pointer(s) to these newly allocated named data type instance(s). The +application must call OCIObjectMarkDel() to deallocate the named data type +instance(s) when they are no longer needed. +pvszsp (IN/OUT) - points to the size of the program variable. For an array, it +is an array of ub4s. On return points to the size(s) of unpickled fetched +values. +indpp (IN/OUT) - points to a pointer to the program variable buffer +containing the parallel indicator structure. For an array, points to an array +of pointers. Memory is allocated to store the indicator structures in the +object cache. At the end of the fetch when all values have been received, +indpp points to the pointer(s) to these newly allocated indicator structure(s). +indszp (IN/OUT) - points to the size(s) of the indicator structure program +variable. For an array, it is an array of ub4s. On return points to the size(s) +of the unpickled fetched indicator values. +Related Functions +OCIAttrGet() + + + +OCIDescAlloc() +Name +OCI Get DESCriptor or lob locator +Purpose +Allocates storage to hold certain data types. The descriptors can be used as +bind or define variables. +Syntax +sword OCIDescAlloc ( const void *parenth, + void **descpp, + ub4 type, + size_t xtramem_sz, + void **usrmempp); +Comments +Returns a pointer to an allocated and initialized structure, corresponding to +the type specified in type. A non-NULL descriptor or LOB locator is returned +on success. No diagnostics are available on error. +This call returns OCI_SUCCESS if successful, or OCI_INVALID_HANDLE if +an out-of-memory error occurs. +Parameters +parenth (IN) - an environment handle. +descpp (OUT) - returns a descriptor or LOB locator of desired type. +type (IN) - specifies the type of descriptor or LOB locator to be allocated. +The specific types are: +OCI_DTYPE_SNAP - specifies generation of snapshot descriptor of C +type - OCISnapshot +OCI_DTYPE_LOB - specifies generation of a LOB data type locator of C +type - OCILobLocator +OCI_DTYPE_RSET - specifies generation of a descriptor of C type +OCIResult that references a result set (a number of rows as a result of a +query). This descriptor is bound to a bind variable of data type +SQLT_RSET (result set). The descriptor has to be converted into a +statement handle using a function - OCIResultSetToStmt() - which can +then be passed to OCIDefineByPos() and OCIStmtFetch() to retrieve the +rows of the result set. +OCI_DTYPE_ROWID - specifies generation of a ROWID descriptor of C +type OCIRowid. +OCI_DTYPE_COMPLEXOBJECTCOMP - specifies generation of a +complex object retrieval descriptor of C type +OCIComplexObjectComp. +xtramemsz (IN) - specifies an amount of user memory to be allocated for use +by the application. +usrmempp (OUT) - returns a pointer to the user memory of size xtramemsz +allocated by the call for the user. +Related Functions +OCIDescFree() + + + + +OCIDescFree() +Name +OCI Free DESCriptor +Purpose +Deallocates a previously allocated descriptor. +Syntax +sword OCIDescFree ( void *descp, + ub4 type); +Comments +This call frees up storage associated with the descriptor, corresponding to the +type specified in type. Returns OCI_SUCCESS or OCI_INVALID_HANDLE. +All descriptors must be explicitly deallocated. OCI will not deallocate a +descriptor if the environment handle is deallocated. +Parameters +descp (IN) - an allocated descriptor. +type (IN) - specifies the type of storage to be freed. The specific types are: +OCI_DTYPE_SNAP - snapshot descriptor +OCI_DTYPE_LOB - a LOB data type descriptor +OCI_DTYPE_RSET - a descriptor that references a result set (a number +of rows as a result of a query). +OCI_DTYPE_ROWID - a ROWID descriptor +OCI_DTYPE_COMPLEXOBJECTCOMP - a complex object retrieval +descriptor +Related Functions +OCIDescAlloc() + + + +OCIDescribeAny() +Name +OCI DeSCribe Any +Purpose +Describes existing schema objects. +Syntax +sword OCIDescribeAny ( OCISvcCtx *svchp, + OCIError *errhp, + void *objptr, + ub4 objnm_len, + ub1 objptr_typ, + ub1 info_level, + ub1 objtype, + OCIDesc *dschp ); +Comments +This is a generic describe call that describes existing schema objects: tables, +views, synonyms, procedures, functions, packages, sequences, and types. As a +result of this call, the describe handle is populated with the object-specific +attributes which can be obtained through an OCIAttrGet() call. +An OCIParamGet() on the describe handle returns a parameter descriptor for a +specified position. Parameter positions begin with 1. Calling OCIAttrGet() on +the parameter descriptor returns the specific attributes of a stored procedure +or function parameter or a table column descriptor as the case may be. +These subsequent calls do not need an extra round trip to the server because +the entire schema object description cached on the client side by +OCIDescribeAny(). Calling OCIAttrGet() on the describe handle can also return +the total number of positions. +See the section "Describing" on page 2-33 for more information about describe +operations. +Parameters +TO BE UPDATED +svchp (IN/OUT) - a service context handle. +errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +objptr (IN) - the name of the object (a null-terminated string) to be +described. Only procedure or function names are valid when connected to an +Oracle7 Server. +objptr_len (IN) - the length of the string. Must be non-zero. +objptr_typ (IN) - Must be OCI_OTYPE_NAME, OCI_OTYPE_REF, or OCI_OTYPE_PTR. +info_level (IN) - reserved for future extensions. Pass OCI_DEFAULT. +objtype (IN/OUT) - object type. +dschp (IN/OUT) - a describe handle that is populated with describe +information about the object after the call. +Related Functions +OCIAttrGet() + + + +OCIEnvCreate() +Name +OCI ENVironment CREATE +Purpose +This function creates and initializes an environment for the rest of +the OCI functions to work under. This call is a replacement for both +the OCIInitialize and OCIEnvInit calls. +Syntax +sword OCIEnvCreate ( OCIEnv **envhpp, + ub4 mode, + const void *ctxp, + const void *(*malocfp) + (void *ctxp, + size_t size), + const void *(*ralocfp) + (void *ctxp, + void *memptr, + size_t newsize), + const void (*mfreefp) + ( void *ctxp, + void *memptr)) + size_t xtramemsz, + void **usrmempp ); + +Comments +This call creates an environment for all the OCI calls using the modes +specified by the user. This call can be used instead of the two calls +OCIInitialize and OCIEnvInit. This function returns an environment handle +which is then used by the remaining OCI functions. There can be multiple +environments in OCI each with its own environment modes. This function +also performs any process level initialization if required by any mode. +For example if the user wants to initialize an environment as OCI_THREADED, +then all libraries that are used by OCI are also initialized in the +threaded mode. + +This call should be invoked before anny other OCI call and should be used +instead of the OCIInitialize and OCIEnvInit calls. This is the recommended +call, although OCIInitialize and OCIEnvInit calls will still be supported +for backward compatibility. + +envpp (OUT) - a pointer to a handle to the environment. +mode (IN) - specifies initialization of the mode. The valid modes are: +OCI_DEFAULT - default mode. +OCI_THREADED - threaded environment. In this mode, internal data +structures are protected from concurrent accesses by multiple threads. +OCI_OBJECT - will use navigational object interface. +ctxp (IN) - user defined context for the memory call back routines. +malocfp (IN) - user-defined memory allocation function. If mode is +OCI_THREADED, this memory allocation routine must be thread safe. +ctxp - context pointer for the user-defined memory allocation function. +size - size of memory to be allocated by the user-defined memory +allocation function +ralocfp (IN) - user-defined memory re-allocation function. If mode is +OCI_THREADED, this memory allocation routine must be thread safe. +ctxp - context pointer for the user-defined memory reallocation +function. +memp - pointer to memory block +newsize - new size of memory to be allocated +mfreefp (IN) - user-defined memory free function. If mode is +OCI_THREADED, this memory free routine must be thread safe. +ctxp - context pointer for the user-defined memory free function. +memptr - pointer to memory to be freed +xtramemsz (IN) - specifies the amount of user memory to be allocated. +usrmempp (OUT) - returns a pointer to the user memory of size xtramemsz +allocated by the call for the user. + +Example + +Related Functions +OCIInitialize, OCIEnvInit + +OCIEnvNlsCreate() +Name +OCI ENVironment CREATE with NLS info +Purpose +This function does almost everything OCIEnvCreate does, plus enabling setting +of charset and ncharset programmatically, except OCI_UTF16 mode. +Syntax +sword OCIEnvNlsCreate(OCIEnv **envhpp, + ub4 mode, + void *ctxp, + void *(*malocfp) + (void *ctxp, + size_t size), + void *(*ralocfp) + (void *ctxp, + void *memptr, + size_t newsize), + void (*mfreefp) + (void *ctxp, + void *memptr), + size_t xtramemsz, + void **usrmempp, + ub2 charset, + ub2 ncharset) +Comments +The charset and ncharset must be both zero or non-zero. +The parameters have the same meaning as the ones in OCIEnvCreate(). +When charset or ncharset is non-zero, the corresponding character set will +be used to replace the ones specified in NLS_LANG or NLS_NCHAR. Moreover, +OCI_UTF16ID is allowed to be set as charset and ncharset. +On the other hand, OCI_UTF16 mode is deprecated with this function. +Applications can achieve the same effects by setting +both charset and ncharset as OCI_UTF16ID. + + +OCIEnvInit() +Name +OCI INITialize environment +Purpose +This call initializes the OCI environment handle. +Syntax +sword OCIEnvInit ( OCIEnv **envp, + ub4 mode, + size_t xtramemsz, + void **usrmempp ); +Comments +Initializes the OCI environment handle. No changes are done on an initialized +handle. If OCI_ERROR or OCI_SUCCESS_WITH_INFO is returned, the +environment handle can be used to obtain ORACLE specific errors and +diagnostics. +This call is processed locally, without a server round-trip. +Parameters +envpp (OUT) - a pointer to a handle to the environment. +mode (IN) - specifies initialization of an environment mode. The only valid +mode is OCI_DEFAULT for default mode +xtramemsz (IN) - specifies the amount of user memory to be allocated. +usrmempp (OUT) - returns a pointer to the user memory of size xtramemsz +allocated by the call for the user. +Example +See the description of OCISessionBegin() on page 13-84 for an example showing +the use of OCIEnvInit(). +Related Functions + + + + +OCIErrorGet() +Name +OCI Get Diagnostic Record +Purpose +Returns an error message in the buffer provided and an ORACLE error. +Syntax +sword OCIErrorGet ( void *hndlp, + ub4 recordno, + OraText *sqlstate, + ub4 *errcodep, + OraText *bufp, + ub4 bufsiz, + ub4 type ); +Comments +Returns an error message in the buffer provided and an ORACLE error. +Currently does not support SQL state. This call can be called a multiple +number of times if there are more than one diagnostic record for an error. +The error handle is originally allocated with a call to OCIHandleAlloc(). +Parameters +hndlp (IN) - the error handle, in most cases, or the environment handle (for +errors on OCIEnvInit(), OCIHandleAlloc()). +recordno (IN) - indicates the status record from which the application seeks +info. Starts from 1. +sqlstate (OUT) - Not supported in Version 8.0. +errcodep (OUT) - an ORACLE Error is returned. +bufp (OUT) - the error message text is returned. +bufsiz (IN) - the size of the buffer provide to get the error message. +type (IN) - the type of the handle. +Related Functions +OCIHandleAlloc() + +OCIExtractInit +Name +OCI Extract Initialize +Purpose +This function initializes the parameter manager. +Syntax +sword OCIExtractInit(void *hndl, OCIError *err); +Comments +It must be called before calling any other parameter manager routine. The NLS +information is stored inside the parameter manager context and used in +subsequent calls to OCIExtract routines. +Returns OCI_SUCCESS, OCI_INVALID_HANDLE, or OCI_ERROR +Parameters +hndl (IN/OUT) - The OCI environment or session handle. +err (IN/OUT) - The OCI error handle. If there is an error, it is recorded in + err and this function returns OCI_ERROR. Diagnostic information + can be obtained by calling OCIErrorGet(). +Related Functions +OCIExtractTerm() + +OCIExtractTerm +Name +OCI Extract Terminate +Purpose +This function releases all dynamically allocated storage and may perform +other internal bookkeeping functions. +Syntax +sword OCIExtractTerm(void *hndl, OCIError *err); +Comments +It must be called when the parameter manager is no longer being used. +Returns OCI_SUCCESS, OCI_INVALID_HANDLE, or OCI_ERROR +Parameters +hndl (IN/OUT) - The OCI environment or session handle. +err (IN/OUT) - The OCI error handle. If there is an error, it is recorded in + err and this function returns OCI_ERROR. Diagnostic information + can be obtained by calling OCIErrorGet(). +Related Functions +OCIExtractInit() + +OCIExtractReset +Name +OCI Extract Reset +Purpose +The memory currently used for parameter storage, key definition storage, and +parameter value lists is freed and the structure is reinitialized. +Syntax +sword OCIExtractReset(void *hndl, OCIError *err); +Comments +Returns OCI_SUCCESS, OCI_INVALID_HANDLE, or OCI_ERROR +Parameters +hndl (IN/OUT) - The OCI environment or session handle. +err (IN/OUT) - The OCI error handle. If there is an error, it is recorded in + err and this function returns OCI_ERROR. Diagnostic information + can be obtained by calling OCIErrorGet(). +Related Functions + +OCIExtractSetNumKeys +Name +OCI Extract Set Number of Keys +Purpose +Informs the parameter manager of the number of keys that will be registered. +Syntax +sword OCIExtractSetNumKeys(void *hndl, OCIError *err, uword numkeys); +Comments +This routine must be called prior to the first call of OCIExtractSetKey(). +Returns OCI_SUCCESS, OCI_INVALID_HANDLE, or OCI_ERROR +Parameters +hndl (IN/OUT) - The OCI environment or session handle. +err (IN/OUT) - The OCI error handle. If there is an error, it is recorded in + err and this function returns OCI_ERROR. Diagnostic information + can be obtained by calling OCIErrorGet(). +numkeys (IN) - The number of keys that will be registered with + OCIExtractSetKey(). +Related Functions +OCIExtractSetKey() + +OCIExtractSetKey +Name +OCI Extract Set Key definition +Purpose +Registers information about a key with the parameter manager. +Syntax +sword OCIExtractSetKey(void *hndl, OCIError *err, const OraText *name, + ub1 type, ub4 flag, const void *defval, + const sb4 *intrange, const OraText *const *strlist); +Comments +This routine must be called after calling OCIExtractSetKey() and before +calling OCIExtractFromFile() or OCIExtractFromStr(). +Returns OCI_SUCCESS, OCI_INVALID_HANDLE, or OCI_ERROR +Parameters +hndl (IN/OUT) - The OCI environment or session handle. +err (IN/OUT) - The OCI error handle. If there is an error, it is recorded in + err and this function returns OCI_ERROR. Diagnostic information + can be obtained by calling OCIErrorGet(). +name (IN) - The name of the key. +type (IN) - The type of the key (OCI_EXTRACT_TYPE_INTEGER, + OCI_EXTRACT_TYPE_OCINUM, OCI_EXTRACT_TYPE_STRING, or + OCI_EXTRACT_TYPE_BOOLEAN). +flag (IN) - Set to OCI_EXTRACT_MULTIPLE if the key can take multiple values + or 0 otherwise. +defval (IN) - Set to the default value for the key. May be NULL if there is + no default. A string default must be a (text*) type, an + integer default must be an (sb4*) type, and a boolean default + must be a (ub1*) type. +intrange (IN) - Starting and ending values for the allowable range of integer + values. May be NULL if the key is not an integer type or if + all integer values are acceptable. +strlist (IN) - List of all acceptable text strings for the key. May be NULL + if the key is not a string type or if all text values are + acceptable. +Related Functions +OCIExtractSetNumKeys() + +OCIExtractFromFile +Name +OCI Extract parameters From File +Purpose +The keys and their values in the given file are processed. +Syntax +sword OCIExtractFromFile(void *hndl, OCIError *err, ub4 flag, + OraText *filename); +Comments +Returns OCI_SUCCESS, OCI_INVALID_HANDLE, or OCI_ERROR +Parameters +hndl (IN/OUT) - The OCI environment or session handle. +err (IN/OUT) - The OCI error handle. If there is an error, it is recorded in + err and this function returns OCI_ERROR. Diagnostic information + can be obtained by calling OCIErrorGet(). +flag (IN) - Zero or has one or more of the following bits set: + OCI_EXTRACT_CASE_SENSITIVE, OCI_EXTRACT_UNIQUE_ABBREVS, or + OCI_EXTRACT_APPEND_VALUES. +filename (IN) - Null-terminated filename string. +Related Functions + +OCIExtractFromStr +Name +OCI Extract parameters From String +Purpose +The keys and their values in the given string are processed. +Syntax +sword OCIExtractFromStr(void *hndl, OCIError *err, ub4 flag, OraText *input); +Comments +Returns OCI_SUCCESS, OCI_INVALID_HANDLE, or OCI_ERROR +Parameters +hndl (IN/OUT) - The OCI environment or session handle. +err (IN/OUT) - The OCI error handle. If there is an error, it is recorded in + err and this function returns OCI_ERROR. Diagnostic information + can be obtained by calling OCIErrorGet(). +flag (IN) - Zero or has one or more of the following bits set: + OCI_EXTRACT_CASE_SENSITIVE, OCI_EXTRACT_UNIQUE_ABBREVS, or + OCI_EXTRACT_APPEND_VALUES. +input (IN) - Null-terminated input string. +Related Functions + +OCIExtractToInt +Name +OCI Extract To Integer +Purpose +Gets the integer value for the specified key. +Syntax +sword OCIExtractToInt(void *hndl, OCIError *err, OraText *keyname, + uword valno, sb4 *retval); +Comments +The valno'th value (starting with 0) is returned. +Returns OCI_SUCCESS, OCI_INVALID_HANDLE, OCI_NO_DATA, or OCI_ERROR. +OCI_NO_DATA means that there is no valno'th value for this key. +Parameters +hndl (IN) - The OCI environment or session handle. +err (IN/OUT) - The OCI error handle. If there is an error, it is recorded in + err and this function returns OCI_ERROR. Diagnostic information + can be obtained by calling OCIErrorGet(). +keyname (IN) - Key name. +valno (IN) - Which value to get for this key. +retval (OUT) - The actual integer value. +Related Functions + +OCIExtractToBool +Name +OCI Extract To Boolean +Purpose +Gets the boolean value for the specified key. +Syntax +sword OCIExtractToBool(void *hndl, OCIError *err, OraText *keyname, + uword valno, ub1 *retval); +Comments +The valno'th value (starting with 0) is returned. +Returns OCI_SUCCESS, OCI_INVALID_HANDLE, OCI_NO_DATA, or OCI_ERROR. +OCI_NO_DATA means that there is no valno'th value for this key. +Parameters +hndl (IN) - The OCI environment or session handle. +err (IN/OUT) - The OCI error handle. If there is an error, it is recorded in + err and this function returns OCI_ERROR. Diagnostic information + can be obtained by calling OCIErrorGet(). +keyname (IN) - Key name. +valno (IN) - Which value to get for this key. +retval (OUT) - The actual boolean value. +Related Functions + +OCIExtractToStr +Name +OCI Extract To String +Purpose +Gets the string value for the specified key. +Syntax +sword OCIExtractToStr(void *hndl, OCIError *err, OraText *keyname, + uword valno, OraText *retval, uword buflen); +Comments +The valno'th value (starting with 0) is returned. +Returns OCI_SUCCESS, OCI_INVALID_HANDLE, OCI_NO_DATA, or OCI_ERROR. +OCI_NO_DATA means that there is no valno'th value for this key. +Parameters +hndl (IN) - The OCI environment or session handle. +err (IN/OUT) - The OCI error handle. If there is an error, it is recorded in + err and this function returns OCI_ERROR. Diagnostic information + can be obtained by calling OCIErrorGet(). +keyname (IN) - Key name. +valno (IN) - Which value to get for this key. +retval (OUT) - The actual null-terminated string value. +buflen (IN) - The length of the buffer for retval. +Related Functions + +Note: The following OCIExtract functions are unavailable in this release + +OCIExtractToOCINum +Name +OCI Extract To OCI Number +Purpose +Gets the OCINumber value for the specified key. +Syntax +sword OCIExtractToOCINum(void *hndl, OCIError *err, OraText *keyname, + uword valno, OCINumber *retval); +Comments +The valno'th value (starting with 0) is returned. +Returns OCI_SUCCESS, OCI_INVALID_HANDLE, OCI_NO_DATA, or OCI_ERROR. +OCI_NO_DATA means that there is no valno'th value for this key. +Parameters +hndl (IN) - The OCI environment or session handle. +err (IN/OUT) - The OCI error handle. If there is an error, it is recorded in + err and this function returns OCI_ERROR. Diagnostic information + can be obtained by calling OCIErrorGet(). +keyname (IN) - Key name. +valno (IN) - Which value to get for this key. +retval (OUT) - The actual OCINumber value. +Related Functions + +OCIExtractToList +Name +OCI Extract To parameter List +Purpose +Generates a list of parameters from the parameter structures that are stored +in memory. +Syntax +sword OCIExtractToList(void *hndl, OCIError *err, uword *numkeys); +Comments +Must be called before OCIExtractValues() is called. +Returns OCI_SUCCESS, OCI_INVALID_HANDLE, or OCI_ERROR +Parameters +hndl (IN) - The OCI environment or session handle. +err (IN/OUT) - The OCI error handle. If there is an error, it is recorded in + err and this function returns OCI_ERROR. Diagnostic information + can be obtained by calling OCIErrorGet(). +numkeys (OUT) - Number of distinct keys stored in memory. +Related Functions +OCIExtractFromList() + +OCIExtractFromList +Name +OCI Extract From parameter List +Purpose +Generates a list of values for the a parameter in the parameter list. +Syntax +sword OCIExtractFromList(void *hndl, OCIError *err, uword index, + OraText *name, ub1 *type, uword *numvals, + void ***values); +Comments +Parameters are specified by an index. OCIExtractToList() must be called prior +to calling this routine to generate the parameter list from the parameter +structures that are stored in memory. +Returns OCI_SUCCESS, OCI_INVALID_HANDLE, or OCI_ERROR +Parameters +hndl (IN) - The OCI environment or session handle. +err (IN/OUT) - The OCI error handle. If there is an error, it is recorded in + err and this function returns OCI_ERROR. Diagnostic information + can be obtained by calling OCIErrorGet(). +name (OUT) - Name of the key for the current parameter. +type (OUT) - Type of the current parameter (OCI_EXTRACT_TYPE_STRING, + OCI_EXTRACT_TYPE_INTEGER, OCI_EXTRACT_TYPE_OCINUM, or + OCI_EXTRACT_TYPE_BOOLEAN) +numvals (OUT) - Number of values for this parameter. +values (OUT) - The values for this parameter. +Related Functions +OCIExtractToList() + + +************************ OCIFileClose() *********************************** + +Name + OCIFileClose - Oracle Call Interface FILE i/o CLOSE + +Purpose + Close a previously opened file. + +Syntax + sword OCIFileClose ( void *hndl, + OCIError *err, + OCIFileObject *filep ) + +Comments + This function will close a previously opened file. If the function succeeds + then OCI_SUCCESS will be returned, else OCI_ERROR. + +Parameters + hndl (IN) - the OCI environment or session handle. + err (OUT) - the OCI error handle + filep (IN) - the OCIFile file object + +Related Functions + OCIFileOpen. + + + +********************* OCIFileExists() ************************************** + +Name + OCIFileExists - Oracle Call Interface FILE i/o EXIST + +Purpose + Check to see if the file exists. + +Syntax + sword OCIFileExists ( void *hndl, + OCIError *err, + OraText *filename, + OraText *path, + ub1 *flag ) + +Comments + This function will set the flag to TRUE if the file exists else it will + be set to FALSE. + The function will return OCI_ERROR if any error is encountered, else + it will return OCI_ERROR. + +Parameters + hndl(IN) - OCI environment or session handle + err(OUT) - OCI error handle + filename(IN) - filename + path(IN) - path of the file + flag(OUT) - whether the file exists or not + +Related Functions. + None. + + + **************************** OCIFileFlush() ****************************** + + +Name + OCIFileFlush - Oracle Call Interface File i/o FLUSH + +Purpose + Flush the buffers associated with the file to the disk. + +Syntax + sword OCIFileFlush ( void *hndl, + OCIError *err, + OCIFileObject *filep ) + +Comments + The function will return OCI_ERROR if any error is encountered, else + it will return OCI_ERROR. + +Parameters + hndl (IN) - the OCI environment or session handle. + err (OUT) - the OCI error handle + filep (IN) - the OCIFile file object + +Related Functions + OCIFileOpen, OCIFileWrite + + + + *************************** OCIFileGetLength() **************************** + +Name + OCIFileGetLength - Oracle Call Interface FILE i/o GET file LENGTH + +Purpose + Get the length of a file. + +Syntax + OCIFileGetLength(void *hndl, + OCIError *err, + OraText *filename, + OraText *path, + ubig_ora *lenp ) + +Comments + The length of the file will be returned in lenp. + The function will return OCI_ERROR if any error is encountered, else + it will return OCI_ERROR. + +Parameters + hndl (IN) - the OCI environment or session handle. + err (OUT) - the OCI error handle. If there is an error, it is recorded + in err and this function returns OCI_ERROR. Diagnostic information can be + obtained by calling OCIErrorGet(). + filename (IN) - file name. + path (IN) - path of the file. + lenp (OUT) - On output, it is the length of the file in bytes. + is the number of bytes in the file. + +Related Functions + None. + + + +******************************** OCIFileInit() ***************************** + +Name + OCIFileInit - Oracle Call Interface FILE i/o INITialize + +Purpose + Initialize the OCI File I/O package and create the OCIFile context. + +Syntax + sword OCIFileInit ( void *hndl, + OCIError *err) + +Comments + This function should be called before any of the OCIFile functions are + used. + The function will return OCI_ERROR if any error is encountered, else + it will return OCI_ERROR. + +Parameters + hndl(IN) - OCI environment or session handle. + err(OUT) - OCI error structure. + +Related Functions + OCIFileTerm + + + +********************************* OCIFileOpen() ***************************** + +Name + OCIFileOpen - Oracle Call Interface File i/o OPEN + +Purpose + Open a file. + +Syntax + sword OCIFileOpen ( void *hndl, + OCIError *err, + OCIFileObject **filep, + OraText *filename, + OraText *path, + ub4 mode, + ub4 create, + ub4 type ) + +Comments + OCIFileOpen returns a handle to the open file in filep if the file is + successfully opened. + If one wants to use the standard file objects (stdin, stdout & stderr) + then OCIFileOpen whould be called with the type filed containing the + appropriate type (see the parameter type). If any of the standard files + are specified then filename, path, mode and create are ignored. + The function will return OCI_ERROR if any error is encountered, else + it will return OCI_ERROR. + +Parameters + hndl (OUT) - the OCI environment or session handle. + err (OUT) - the OCI error handle. If there is an error, it is recorded + in err and this function returns OCI_ERROR. Diagnostic information can be + obtained by calling OCIErrorGet(). + filep (OUT) - the file object to be returned. + filename (IN) - file name (NULL terminated string). + path (IN) - path of the file (NULL terminated string). + mode - mode in which to open the file (valid modes are OCI_FILE_READONLY, + OCI_FILE_WRITEONLY, OCI_FILE_READ_WRITE). + create - should the file be created if it does not exist. Valid values + are: + OCI_FILE_TRUNCATE - create a file regardless of whether or not it exists. + If the file already exists overwrite it. + OCI_FILE_EXIST - open it if it exists, else fail. + OCI_FILE_EXCL - fail if the file exists, else create. + OCI_FILE_CREATE - open the file if it exists, and create it if it doesn't. + OCI_FILE_APPEND - set the file pointer to the end of the file prior to + writing(this flag can be OR'ed with OCI_FILE_EXIST or + OCI_FILE_CREATE). +type - file type. Valid values are OCI_FILE_TEXT, OCI_FILE_BIN, + OCI_FILE_STDIN, OCI_FILE_STDOUT and OCI_FILE_STDERR. + If any of the standard files are specified then filename, path, mode + and create are ignored. + +Related Functions. + OCIFileClose + + + +************************** OCIFileRead() ************************************ + +Name + OCIFileRead - Oracle Call Interface FILE i/o READ + +Purpose + Read from a file into a buffer. + +Syntax + sword OCIFileRead ( void *hndl, + OCIError *err, + OCIFileObject *filep, + void *bufp, + ub4 bufl, + ub4 *bytesread ) + +Comments + Upto bufl bytes from the file will be read into bufp. The user should + allocate memory for the buffer. + The number of bytes read would be in bytesread. + The function will return OCI_ERROR if any error is encountered, else + it will return OCI_ERROR. + +Parameters + hndl (IN) - the OCI environment or session handle. + err (OUT) - the OCI error handle. If there is an error, it is recorded + in err and this function returns OCI_ERROR. Diagnostic information can be + obtained by calling OCIErrorGet(). + filep (IN/OUT) - a File Object that uniquely references the file. + bufp (IN) - the pointer to a buffer into which the data will be read. The + length of the allocated memory is assumed to be bufl. + bufl - the length of the buffer in bytes. + bytesread (OUT) - the number of bytes read. + +Related Functions + OCIFileOpen, OCIFileSeek, OCIFileWrite + + + +****************************** OCIFileSeek() ****************************** + +Name + OCIFileSeek - Oracle Call Interface FILE i/o SEEK + +Purpose + Perfom a seek to a byte position. + +Syntax + sword OCIFileSeek ( void *hndl, + OCIError *err, + OCIFileObject *filep, + uword origin, + ubig_ora offset, + sb1 dir) + +Comments + The function will return OCI_ERROR if any error is encountered, else + it will return OCI_ERROR. + +Parameters + hndl (IN) - the OCI environment or session handle. + err (OUT) - the OCI error handle. If there is an error, it is recorded + in err and this function returns OCI_ERROR. Diagnostic information can be + obtained by calling OCIErrorGet(). + filep (IN/OUT) - a file handle that uniquely references the file. + origin - The starting point we want to seek from. NOTE: The starting + point may be OCI_FILE_SEEK_BEGINNING (beginning), OCI_FILE_SEEK_CURRENT + (current position), or OCI_FILE_SEEK_END (end of file). + offset - The number of bytes from the origin we want to start reading from. + dir - The direction we want to go from the origin. NOTE: The direction + can be either OCI_FILE_FORWARD or OCI_FILE_BACKWARD. + +Related Function + OCIFileOpen, OCIFileRead, OCIFileWrite + + + +*************************** OCIFileTerm() ********************************** + +Name + OCIFileTerm - Oracle Call Interface FILE i/o TERMinate + +Purpose + Terminate the OCI File I/O package and destroy the OCI File context. + +Syntax + sword OCIFileTerm ( void *hndl, + OCIError *err ) + +Comments + After this function has been called no OCIFile function should be used. + The function will return OCI_ERROR if any error is encountered, else + it will return OCI_ERROR. + +Parameters + hndl(IN) - OCI environment or session handle. + err(OUT) - OCI error structure. + +Related Functions + OCIFileInit + + +********************************* OCIFileWrite() **************************** + +Name + OCIFileWrite - Oracle Call Interface FILE i/o WRITE + +Purpose + Write data from buffer into a file. + +Syntax + sword OCIFileWrite ( void *hndl, + OCIError *err, + OCIFileObject *filep, + void *bufp, + ub4 buflen + ub4 *byteswritten ) + +Comments + The number of bytes written will be in *byteswritten. + The function will return OCI_ERROR if any error is encountered, else + it will return OCI_ERROR. + +Parameters + hndl (IN) - the OCI environment or session handle. + err (OUT) - the OCI error handle. If there is an error, it is recorded + in err and this function returns OCI_ERROR. Diagnostic information can be + obtained by calling OCIErrorGet(). + filep (IN/OUT) - a file handle that uniquely references the file. + bufp (IN) - the pointer to a buffer from which the data will be written. + The length of the allocated memory is assumed to be the value passed + in bufl. + bufl - the length of the buffer in bytes. + byteswritten (OUT) - the number of bytes written. + +Related Functions + OCIFileOpen, OCIFileSeek, OCIFileRead + + + + + +OCIHandleAlloc() +Name +OCI Get HaNDLe +Purpose +This call returns a pointer to an allocated and initialized handle. +Syntax +sword OCIHandleAlloc ( const void *parenth, + void **hndlpp, + ub4 type, + size_t xtramem_sz, + void **usrmempp); +Comments +Returns a pointer to an allocated and initialized structure, corresponding to +the type specified in type. A non-NULL handle is returned on success. Bind +handle and define handles are allocated with respect to a statement handle. All +other handles are allocated with respect to an environment handle which is +passed in as a parent handle. +No diagnostics are available on error. This call returns OCI_SUCCESS if +successful, or OCI_INVALID_HANDLE if an out-of-memory error occurs. +Handles must be allocated using OCIHandleAlloc() before they can be passed +into an OCI call. +Parameters +parenth (IN) - an environment or a statement handle. +hndlpp (OUT) - returns a handle to a handle type. +type (IN) - specifies the type of handle to be allocated. The specific types +are: +OCI_HTYPE_ERROR - specifies generation of an error report handle of +C type OCIError +OCI_HTYPE_SVCCTX - specifies generation of a service context handle +of C type OCISvcCtx +OCI_HTYPE_STMT - specifies generation of a statement (application +request) handle of C type OCIStmt +OCI_HTYPE_BIND - specifies generation of a bind information handle +of C type OCIBind +OCI_HTYPE_DEFINE - specifies generation of a column definition +handle of C type OCIDefine +OCI_HTYPE_DESCRIBE - specifies generation of a select list +description handle of C type OCIDesc +OCI_HTYPE_SERVER - specifies generation of a server context handle +of C type OCIServer +OCI_HTYPE_SESSION - specifies generation of an authentication +context handle of C type OCISession +OCI_HTYPE_TRANS - specifies generation of a transaction context +handle of C type OCITrans +OCI_HTYPE_COMPLEXOBJECT - specifies generation of a complex +object retrieval handle of C type OCIComplexObject +OCI_HTYPE_SECURITY - specifies generation of a security handle of C +type OCISecurity +xtramem_sz (IN) - specifies an amount of user memory to be allocated. +usrmempp (OUT) - returns a pointer to the user memory of size xtramemsz +allocated by the call for the user. +Related Functions +OCIHandleFree() + + + +OCIHandleFree() +Name +OCI Free HaNDLe +Purpose +This call explicitly deallocates a handle. +Syntax +sword OCIHandleFree ( void *hndlp, + ub4 type); +Comments +This call frees up storage associated with a handle, corresponding to the type +specified in the type parameter. +This call returns either OCI_SUCCESS or OCI_INVALID_HANDLE. +All handles must be explicitly deallocated. OCI will not deallocate a child +handle if the parent is deallocated. +Parameters +hndlp (IN) - an opaque pointer to some storage. +type (IN) - specifies the type of storage to be allocated. The specific types +are: +OCI_HTYPE_ENV - an environment handle +OCI_HTYPE_ERROR - an error report handle +OCI_HTYPE_SVCCTX - a service context handle +OCI_HTYPE_STMT - a statement (application request) handle +OCI_HTYPE_BIND - a bind information handle +OCI_HTYPE_DEFINE - a column definition handle +OCI_HTYPE_DESCRIBE - a select list description handle +OCI_HTYPE_SERVER - a server handle +OCI_HTYPE_SESSION - a user authentication handle +OCI_HTYPE_TRANS - a transaction handle +OCI_HTYPE_COMPLEXOBJECT - a complex object retrieval handle +OCI_HTYPE_SECURITY - a security handle +Related Functions +OCIHandleAlloc() + + + + +OCIInitialize() +Name +OCI Process Initialize +Purpose +Initializes the OCI process environment. +Syntax +sword OCIInitialize ( ub4 mode, + const void *ctxp, + const void *(*malocfp) + ( void *ctxp, + size_t size ), + const void *(*ralocfp) + ( void *ctxp, + void *memp, + size_t newsize ), + const void (*mfreefp) + ( void *ctxp, + void *memptr )); +Comments +This call initializes the OCI process environment. +OCIInitialize() must be invoked before any other OCI call. +Parameters +mode (IN) - specifies initialization of the mode. The valid modes are: +OCI_DEFAULT - default mode. +OCI_THREADED - threaded environment. In this mode, internal data +structures are protected from concurrent accesses by multiple threads. +OCI_OBJECT - will use navigational object interface. +ctxp (IN) - user defined context for the memory call back routines. +malocfp (IN) - user-defined memory allocation function. If mode is +OCI_THREADED, this memory allocation routine must be thread safe. +ctxp - context pointer for the user-defined memory allocation function. +size - size of memory to be allocated by the user-defined memory +allocation function +ralocfp (IN) - user-defined memory re-allocation function. If mode is +OCI_THREADED, this memory allocation routine must be thread safe. +ctxp - context pointer for the user-defined memory reallocation +function. +memp - pointer to memory block +newsize - new size of memory to be allocated +mfreefp (IN) - user-defined memory free function. If mode is +OCI_THREADED, this memory free routine must be thread safe. +ctxp - context pointer for the user-defined memory free function. +memptr - pointer to memory to be freed +Example +See the description of OCIStmtPrepare() on page 13-96 for an example showing +the use of OCIInitialize(). +Related Functions + +-------------------------------OCITerminate------------------------------------ + +OCITerminate() +Name +OCI process Terminate +Purpose +Do cleanup before process termination +Syntax +sword OCITerminate (ub4 mode); + +Comments +This call performs OCI related clean up before the OCI process terminates. +If the process is running in shared mode then the OCI process is disconnected +from the shared memory subsystem. + +OCITerminate() should be the last OCI call in any process. + +Parameters +mode (IN) - specifies different termination modes. + +OCI_DEFAULT - default mode. + +Example + +Related Functions +OCIInitialize() + +------------------------ OCIAppCtxSet-------------------------------------- +Name +OCI Application context Set +Purpose +Set an attribute and its value for a particular application context + namespace +Syntax + (sword) OCIAppCtxSet((void *) sesshndl, (void *)nsptr,(ub4) nsptrlen, + (void *)attrptr, (ub4) attrptrlen, (void *)valueptr, + (ub4) valueptrlen, errhp, (ub4)mode); + +Comments +Please note that the information set on the session handle is sent to the +server during the next OCIStatementExecute or OCISessionBegin. + +This information is cleared from the session handle, once the information + has been sent over to the server,and should be setup again if needed. + +Parameters + sesshndl (IN/OUT) - Pointer to a session handle + nsptr (IN) - Pointer to namespace string + nsptrlen (IN) - length of the nsptr + attrptr (IN) - Pointer to attribute string + attrptrlen (IN) - length of the attrptr + valueptr (IN) - Pointer to value string + valueptrlen(IN) - length of the valueptr + errhp (OUT) - Error from the API + mode (IN) - mode of operation (OCI_DEFAULT) + +Returns + error if any +Example + +Related Functions + OCIAppCtxClearAll + + +------------------------ OCIAppCtxClearAll--------------------------------- +Name + OCI Application Context Clear all attributes in a namespace +Purpose + To clear the values all attributes in a namespace +Syntax + (sword) OCIAppCtxClearAll((void *) sesshndl, (void *)nsptr, (ub4) nsptrlen, + (OCIError *)errhp, (ub4)mode); + +Comments +This will clean up the context information on the server side during the +next piggy-back to the server. + +Parameters + sesshndl (IN/OUT) - Pointer to a session handle + nsptr (IN) - Pointer to namespace string where the values of all + attributes are cleared + nsptrlen (IN) - length of the nsptr + errhp (OUT) - Error from the API + mode (IN) - mode of operation (OCI_DEFAULT) +Example + +Returns + error if any + +Related Functions + OCIAppCtxSet +---------------------- OCIIntervalAssign --------------------------------- +sword OCIIntervalAssign(void *hndl, OCIError *err, + const OCIInterval *inpinter, OCIInterval *outinter ); + + DESCRIPTION + Copies one interval to another to create a replica + PARAMETERS + hndl (IN) - Session/Env handle. + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + (IN) inpinter - Input Interval + (OUT) outinter - Output Interval + RETURNS + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_SUCCESS otherwise + + ---------------------- OCIIntervalCheck ------------------------------------ +sword OCIIntervalCheck(void *hndl, OCIError *err, const OCIInterval *interval, + ub4 *valid ); + + DESCRIPTION + Checks the validity of an interval + PARAMETERS + hndl (IN) - Session/Env handle. + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + (IN) interval - Interval to be checked + (OUT) valid - Zero if the interval is valid, else returns an Ored + combination of the following codes. + + Macro name Bit number Error + ---------- ---------- ----- + OCI_INTER_INVALID_DAY 0x1 Bad day + OCI_INTER_DAY_BELOW_VALID 0x2 Bad DAy Low/high bit (1=low) + OCI_INTER_INVALID_MONTH 0x4 Bad MOnth + OCI_INTER_MONTH_BELOW_VALID 0x8 Bad MOnth Low/high bit (1=low) + OCI_INTER_INVALID_YEAR 0x10 Bad YeaR + OCI_INTER_YEAR_BELOW_VALID 0x20 Bad YeaR Low/high bit (1=low) + OCI_INTER_INVALID_HOUR 0x40 Bad HouR + OCI_INTER_HOUR_BELOW_VALID 0x80 Bad HouR Low/high bit (1=low) + OCI_INTER_INVALID_MINUTE 0x100 Bad MiNute + OCI_INTER_MINUTE_BELOW_VALID 0x200 Bad MiNute Low/high bit(1=low) + OCI_INTER_INVALID_SECOND 0x400 Bad SeCond + OCI_INTER_SECOND_BELOW_VALID 0x800 bad second Low/high bit(1=low) + OCI_INTER_INVALID_FRACSEC 0x1000 Bad Fractional second + OCI_INTER_FRACSEC_BELOW_VALID 0x2000 Bad fractional second Low/High + + + RETURNS + OCI_SUCCESS if interval is okay + OCI_INVALID_HANDLE if 'err' is NULL. + + ---------------------- OCIIntervalCompare ----------------------------------- +sword OCIIntervalCompare(void *hndl, OCIError *err, OCIInterval *inter1, + OCIInterval *inter2, sword *result ); + + DESCRIPTION + Compares two intervals, returns 0 if equal, -1 if inter1 < inter2, + 1 if inter1 > inter2 + PARAMETERS + hndl (IN) - Session/Env handle. + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + inter1 (IN) - Interval to be compared + inter2 (IN) - Interval to be compared + result (OUT) - comparison result, 0 if equal, -1 if inter1 < inter2, + 1 if inter1 > inter2 + + RETURNS + OCI_SUCCESS on success + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + the two input datetimes are not mutually comparable. + +---------------------- OCIIntervalDivide ------------------------------------ +sword OCIIntervalDivide(void *hndl, OCIError *err, OCIInterval *dividend, + OCINumber *divisor, OCIInterval *result ); + + DESCRIPTION + Divides an interval by an Oracle Number to produce an interval + PARAMETERS + hndl (IN) - Session/Env handle. + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + dividend (IN) - Interval to be divided + divisor (IN) - Oracle Number dividing `dividend' + result (OUT) - resulting interval (dividend / divisor) + RETURNS + OCI_SUCCESS on success + OCI_INVALID_HANDLE if 'err' is NULL. + + ---------------------- OCIIntervalFromNumber -------------------- +sword OCIIntervalFromNumber(void *hndl, OCIError *err, + OCIInterval *inter, OCINumber *number); + DESCRIPTION + Converts an interval to an Oracle Number + PARAMETERS + hndl (IN) - Session/Env handle. + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + (OUT) interval - Interval to be converted + (IN) number - Oracle number result (in years for YEARMONTH interval + and in days for DAYSECOND) + RETURNS + OCI_SUCCESS on success + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR on error. + NOTES + Fractional portions of the date (for instance, minutes and seconds if + the unit chosen is hours) will be included in the Oracle number produced. + Excess precision will be truncated. + + ---------------------- OCIIntervalFromText --------------------------------- +sword OCIIntervalFromText( void *hndl, OCIError *err, const OraText *inpstr, + size_t str_len, OCIInterval *result ); + + DESCRIPTION + Given an interval string produce the interval represented by the string. + The type of the interval is the type of the 'result' descriptor. + PARAMETERS + + hndl (IN) - Session/Env handle. + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + (IN) inpstr - Input string + (IN) str_len - Length of input string + (OUT) result - Resultant interval + RETURNS + OCI_SUCCESS on success + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + there are too many fields in the literal string + the year is out of range (-4713 to 9999) + if the month is out of range (1 to 12) + if the day of month is out of range (1 to 28...31) + if hour is not in range (0 to 23) + if hour is not in range (0 to 11) + if minute is not in range (0 to 59) + if seconds in minute not in range (0 to 59) + if seconds in day not in range (0 to 86399) + if the interval is invalid + + + ---------------------- OCIIntervalGetDaySecond -------------------- + + DESCRIPTION + Gets values of day second interval + PARAMETERS + hndl (IN) - Session/Env handle. + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + day (OUT) - number of days + hour (OUT) - number of hours + min (OUT) - number of mins + sec (OUT) - number of secs + fsec (OUT) - number of fractional seconds + result (IN) - resulting interval + RETURNS + OCI_SUCCESS on success + OCI_INVALID_HANDLE if 'err' is NULL. + + + ---------------------- OCIIntervalGetYearMonth -------------------- + + DESCRIPTION + Gets year month from an interval + PARAMETERS + hndl (IN) - Session/Env handle. + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + year (OUT) - year value + month (OUT) - month value + result (IN) - resulting interval + RETURNS + OCI_SUCCESS on success + OCI_INVALID_HANDLE if 'err' is NULL. + + + +-------------------------- OCIIntervalAdd ------------------------------ +sword OCIIntervalAdd(void *hndl, OCIError *err, OCIInterval *addend1, + OCIInterval *addend2, OCIInterval *result ); +NAME OCIIntervalAdd - Adds two intervals +PARAMETERS +hndl (IN) - Session/Env handle. +err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). +addend1 (IN) - Interval to be added +addend2 (IN) - Interval to be added +result (OUT) - resulting interval (addend1 + addend2) +DESCRIPTION + Adds two intervals to produce a resulting interval +RETURNS + OCI_SUCCESS on success + OCI_ERROR if: + the two input intervals are not mutually comparable. + the resulting year would go above SB4MAXVAL + the resulting year would go below SB4MINVAL + OCI_INVALID_HANDLE if 'err' is NULL. +NOTES + The two input intervals must be mutually comparable + + ---------------------- OCIIntervalSubtract ------------------------------- +sword OCIIntervalSubtract(void *hndl, OCIError *err, OCIInterval *minuend, + OCIInterval *subtrahend, OCIInterval *result ); +NAME - OCIIntervalSubtract - subtracts two intervals +PARAMETERS +hndl (IN) - Session/Env handle. +err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). +minuend (IN) - interval to be subtracted from +subtrahend (IN) - interval subtracted from minuend +result (OUT) - resulting interval (minuend - subtrahend) +DESCRIPTION + Subtracts two intervals and stores the result in an interval +RETURNS + OCI_SUCCESS on success + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if: + the two input intervals are not mutually comparable. + the resulting leading field would go below SB4MINVAL + the resulting leading field would go above SB4MAXVAL + +---------------------- OCIIntervalMultiply --------------------------------- +sword OCIIntervalMultiply(void *hndl, OCIError *err, const OCIInterval *inter, + OCINumber *nfactor, OCIInterval *result ); + + DESCRIPTION + Multiplies an interval by an Oracle Number to produce an interval + PARAMETERS + hndl (IN) - Session/Env handle. + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + inter (IN) - Interval to be multiplied + nfactor (IN) - Oracle Number to be multiplied + result (OUT) - resulting interval (ifactor * nfactor) + RETURNS + OCI_SUCCESS on success + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if: + the resulting year would go above SB4MAXVAL + the resulting year would go below SB4MINVAL + + + ---------------------- OCIIntervalSetDaySecond -------------------- + + DESCRIPTION + Sets day second interval + PARAMETERS + hndl (IN) - Session/Env handle. + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + day (IN) - number of days + hour (IN) - number of hours + min (IN) - number of mins + sec (IN) - number of secs + fsec (IN) - number of fractional seconds + result (OUT) - resulting interval + RETURNS + OCI_SUCCESS on success + OCI_INVALID_HANDLE if 'err' is NULL. + + + ---------------------- OCIIntervalSetYearMonth -------------------- + + DESCRIPTION + Sets year month interval + PARAMETERS + hndl (IN) - Session/Env handle. + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + year (IN) - year value + month (IN) - month value + result (OUT) - resulting interval + RETURNS + OCI_SUCCESS on success + OCI_INVALID_HANDLE if 'err' is NULL. + + +----------------------- OCIIntervalToNumber --------------------------------- +sword OCIIntervalToNumber(void *hndl, OCIError *err, const OCIInterval *inter, + OCINumber *number); + + DESCRIPTION + Converts an interval to an Oracle Number + PARAMETERS + hndl (IN) - Session/Env handle. + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + (IN) inter - Interval to be converted + (OUT) number - Oracle number result (in years for YEARMONTH interval + and in days for DAYSECOND) + RETURNS + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_SUCCESS on success + NOTES + Fractional portions of the date (for instance, minutes and seconds if + the unit chosen is hours) will be included in the Oracle number produced. + Excess precision will be truncated. + +------------------------------- OCIIntervalToText ------------------------- +sword OCIIntervalToText( void *hndl, OCIError *err, const OCIInterval *inter, + ub1 lfprec, ub1 fsprec, OraText *buffer, + size_t buflen, size_t *resultlen ); + + DESCRIPTION + Given an interval, produces a string representing the interval. + PARAMETERS + hndl (IN) - Session/Env handle. + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + (IN) inter - Interval to be converted + (IN) lfprec - Leading field precision. Number of digits used to + represent the leading field. + (IN) fsprec - Fractional second precision of the interval. Number of + digits used to represent the fractional seconds. + (OUT) buffer - buffer to hold result + (IN) buflen - length of above buffer + (OUT) resultlen - length of result placed into buffer + + RETURNS + OCI_SUCCESS on success + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR + if the buffer is not large enough to hold the result + NOTES + The interval literal will be output as `year' or `[year-]month' for + YEAR-MONTH intervals and as `seconds' or `minutes[:seconds]' or + `hours[:minutes[:seconds]]' or `days[ hours[:minutes[:seconds]]]' for + DAY-TIME intervals (where optional fields are surrounded by brackets). + + ---------------------- OCIIntervalFromTZ -------------------- +sword OCIIntervalFromTZ(void *hndl, OCIError *err, const oratext *inpstring, + size_t str_len, OCIInterval *result); + + DESCRIPTION + Retuns an OCI_DTYPE_INTERVAL_DS OCIInterval with the region id (if + the region is specified in the input string) set and the current + absolute offset or an absolut offset with the region id set to 0. + PARAMETERS + hndl (IN) - Session/Env handle. + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + inpstring (IN) - pointer to the input string + str_len (IN) - inpstring length + result - Output Interval + RETURNS + OCI_SUCCESS on success + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR on error + Bad interval type + Timezone errors + NOTES + The input string must be of the form [+/-]TZH:TZM or 'TZR [TZD]' + + ----------------------- OCIKerbAttrSet --------------------- +sword OCIKerbAttrSet(OCISession *trgthndlp, ub4 auth_mode, + ub1 *ftgt_ticket, ub4 ftgt_ticket_len, + ub1 *ftgt_sesskey, ub4 ftgt_sesskey_len, + ub2 ftgt_keytype, ub4 ftgt_ticket_flags, + sb4 ftgt_auth_time, sb4 ftgt_start_time, + sb4 ftgt_end_time, sb4 ftgt_renew_time, + oratext *ftgt_principal, ub4 ftgt_principal_len, + oratext *ftgt_realm, ub4 ftgt_realm_len, + OCIError *errhp); + + DESCRIPTION + This call sets the attributes required for Kerberos authentication + on the user handle. + + PARAMETERS + trgthndlp (IN) - The pointer to a user handle. + auth_mode (IN) - Indicates what type of Kerberos credentials should + be set. Options are: + + OCI_KERBCRED_PROXY + - Set Kerberos credentials for use with + proxy authentication. + OCI_KERBCRED_CLIENT_IDENTIFIER + - Set Kerberos credentials for use + with secure client identifier. + + ftgt_ticket (IN) - Forwardable Ticket Granting Ticket (FTGT). + ftgt_ticket_len (IN) - Length of FTGT. + ftgt_sesskey(IN) - Session Key associated with FTGT. + ftgt_sesskey_len (IN) - Length of session key. + ftgt_keytype (IN) - Type of encryption key used to encrypt FTGT. + ftgt_ticket_flags (IN) - Flags associated with encryption of FTGT. + ftgt_auth_time (IN) - Authentication time compatible with that in FTGT. + ftgt_start_time (IN) - Start time compatible with that indicated in FTGT. + ftgt_end_time (IN) - End time compatible with that indicated in FTGT. + ftgt_renew_time (IN) - Renew time compatible with that indicated in FTGT. + ftgt_principal (IN) - Client principal name from FTGT. + ftgt_principal_len (IN) - Length of client principal name. + ftgt_realm (IN) - Client realm name from FTGT. + ftgt_realm_len (IN) - Client realm name length. + errhp (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + RETURNS + OCI_SUCCESS on success + OCI_ERROR on error + NOTES + +OCILdaToSvcCtx() +Name +OCI toggle version 7 Lda_Def to SerVice context handle +Purpose +Converts a V7 Lda_Def to a V8 service context handle. +Syntax +sword OCILdaToSvcCtx ( OCISvcCtx **svchpp, + OCIError *errhp, + Lda_Def *ldap ); +Comments +Converts a V7 Lda_Def to a V8 service context handle. The action of this call +can be reversed by passing the resulting service context handle to the +OCISvcCtxToLda() function. +Parameters +svchpp (IN/OUT) - the service context handle. +errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +ldap (IN/OUT) - the V7 logon data area returned by OCISvcCtxToLda() from +this service context. +Related Functions +OCISvcCtxToLda() + + + + +OCILobAppend() + +Name +OCI Lob APpend + +Purpose +Appends a LOB value at the end of another LOB. + +Syntax +sword OCILobAppend ( OCISvcCtx *svchp, + OCIError *errhp, + OCILobLocator *dst_locp, + OCILobLocator *src_locp ); +Comments +Appends a LOB value at the end of LOB. The data is +copied from the source to the destination at the end of the destination. The +source and the destination must already exist. The destination LOB is +extended to accommodate the newly written data. + +It is an error to extend the destination LOB beyond the maximum length +allowed or to try to copy from a NULL LOB. + +Parameters +svchp (IN) - the service context handle. +errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +dst_locp (IN/OUT) - a locator uniquely referencing the destination LOB. +src_locp (IN/OUT) - a locator uniquely referencing the source LOB. + +Related Functions +OCILobTrim() +OCIErrorGet() +OCILobWrite() +OCILobCopy() + + + +OCILobAssign() + +Name +OCI Lob ASsiGn + +Purpose +Assigns one LOB/FILE locator to another. + +Syntax +sword OCILobAssign ( OCIEnv *envhp, + OCIError *errhp, + const OCILobLocator *src_locp, + OCILobLocator **dst_locpp ); + +Comments +Assign source locator to destination locator. After the assignment, both +locators refer to the same LOB data. For internal LOBs, the source locator's +LOB data gets copied to the destination locator's LOB data only when the +destination locator gets stored in the table. Therefore, issuing a flush of +the object containing the destination locator will copy the LOB data. For +FILEs only the locator that refers to the OS file is copied to the table. The +OS file is not copied. +Note: The only difference between this and OCILobLocatorAssign is that this +takes an environment handle whereas OCILobLocatorAssign takes an OCI service +handle + +Parameters +envhp (IN/OUT) - OCI environment handle initialized in object mode. +errhp (IN/OUT) - The OCI error handle. If there is an error, it is recorded +in errhp and this function returns OCI_ERROR. Diagnostic information can be +obtained by calling OCIErrorGet(). +src_locp (IN) - LOB locator to copy from. +dst_locpp (IN/OUT) - LOB locator to copy to. The caller must allocate space +for the OCILobLocator by calling OCIDescriptorAlloc(). + +See also +OCIErrorGet() +OCILobIsEqual() +OCILobLocatorIsInit() +OCILobLocatorAssign() + + +OCILobCharSetForm() + +Name +OCI Lob Get Character Set Form + +Purpose +Gets the LOB locator's character set fpr,, if any. + +Syntax +sword OCILobCharSetForm ( OCIEnv *envhp, + OCIError *errhp, + const OCILobLocator *locp, + ub1 *csfrm ); + +Comments +Returns the character set form of the input LOB locator in the csfrm output +parameter. + +Parameters +envhp (IN/OUT) - OCI environment handle initialized in object mode. +errhp (IN/OUT) - error handle. The OCI error handle. If there is an error, it +is recorded in err and this function returns OCI_ERROR. Diagnostic +information can be obtained by calling OCIErrorGet(). +locp (IN) - LOB locator for which to get the character set form. +csfrm(OUT) - character set form of the input LOB locator. If the input +locator is for a BLOB or a BFILE, csfrm is set to 0 since there is no concept +of a character set for binary LOBs/FILEs. The caller must allocate space for +the csfrm (ub1) and not write into the space. +See also +OCIErrorGet(), OCILobCharSetId(), OCILobLocatorIsInit + + + +OCILobCharSetId() + +Name +OCI Lob get Character Set IDentifier + +Purpose +Gets the LOB locator's character set ID, if any. + +Syntax +sword OCILobCharSetId ( OCIEnv *envhp, + OCIError *errhp, + const OCILobLocator *locp, + ub2 *csid ); + +Comments +Returns the character set ID of the input LOB locator in the cid output +parameter. + +Parameters +envhp (IN/OUT) - OCI environment handle initialized in object mode. +errhp (IN/OUT) - error handle. The OCI error handle. If there is an error, it +is recorded in err and this function returns OCI_ERROR. Diagnostic +information can be obtained by calling OCIErrorGet(). +locp (IN) - LOB locator for which to get the character set ID. +csid (OUT) - character set ID of the input LOB locator. If the input locator +is for a BLOB or a BFILE, csid is set to 0 since there is no concept of a +character set for binary LOBs/FILEs. The caller must allocate space for the +character set id of type ub2 and not write into the space. + +See also +OCIErrorGet(), OCILobCharSetForm(), OCILobLocatorIsInit() + + + +OCILobCopy() + +Name +OCI Lob Copy + +Purpose +Copies a portion of a LOB value into another LOB value. + +Syntax +sword OCILobCopy ( OCISvcCtx *svchp, + OCIError *errhp, + OCILobLocator *dst_locp, + OCILobLocator *src_locp, + ub4 amount, + ub4 dst_offset, + ub4 src_offset ); + +Comments +Copies a portion of a LOB value into another LOB as specified. The data +is copied from the source to the destination. The source (src_locp) and the +destination (dlopb) LOBs must already exist. +If the data already exists at the destination's start position, it is +overwritten with the source data. If the destination's start position is +beyond the end of the current data, a hole is created from the end of the data +to the beginning of the newly written data from the source. The destination +LOB is extended to accommodate the newly written data if it extends +beyond the current length of the destination LOB. +It is an error to extend the destination LOB beyond the maximum length +allowed or to try to copy from a NULL LOB. +Parameters +svchp (IN) - the service context handle. +errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +dst_locp (IN/OUT) - a locator uniquely referencing the destination LOB. +src_locp (IN/OUT) - a locator uniquely referencing the source LOB. +amount (IN) - the number of character or bytes, as appropriate, to be copied. +dst_offset (IN) - this is the absolute offset for the destination LOB. +For character LOBs it is the number of characters from the beginning of the +LOB at which to begin writing. For binary LOBs it is the number of bytes from +the beginning of the lob from which to begin reading. The offset starts at 1. +src_offset (IN) - this is the absolute offset for the source LOB. +For character LOBs it is the number of characters from the beginning of the +LOB, for binary LOBs it is the number of bytes. Starts at 1. + +See Also +OCIErrorGet(), OCILobAppend(), OCILobWrite(), OCILobTrim() + +OCILobCreateTemporary() + +Name +OCI Lob Create Temporary + +Purpose +Create a Temporary Lob + +Syntax +sword OCILobCreateTemporary(OCISvcCtx *svchp, + OCIError *errhp, + OCILobLocator *locp, + ub2 csid, + ub1 csfrm, + ub1 lobtype, + boolean cache, + OCIDuration duration); + + +Comments +svchp (IN) - the service context handle. +errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +locp (IN/OUT) - a locator which points to the temporary Lob +csid (IN) - the character set id +csfrm(IN) - the character set form +lobtype (IN) - the lob type - one of the three constants OCI_TEMP_BLOB, + OCI_TEMP_CLOB and OCI_TEMP_NCLOB +cache(IN)- TRUE if the temporary LOB goes through the cache; FALSE, if not. +duration(IN)- duration of the temporary LOB; Can be a valid duration id or one + of the values: OCI_DURATION_SESSION, OCI_DURATION_CALL + Note: OCI_DURATION_TRANSACTION is NOT supported in 8.1 +Related functions +OCILobFreeTemporary() +OCILobIsTemporary() + +OCILobDisableBuffering() + +Name +OCI Lob Disable Buffering + +Purpose +Disable lob buffering for the input locator. + + +Syntax +sword OCILobDisableBuffering ( OCISvcCtx *svchp, + OCIError *errhp, + OCILobLocator *locp); + +Comments + +Disable lob buffering for the input locator. The next time data is +read/written from/to the lob through the input locator, the lob +buffering subsystem is *not* used. Note that this call does *not* +implicitly flush the changes made in the buffering subsystem. The +user must explicitly call OCILobFlushBuffer() to do this. + +Parameters +svchp (IN) - the service context handle. +errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +locp (IN/OUT) - a locator uniquely referencing the LOB. + +Related Functions +OCILobEnableBuffering() +OCIErrorGet() +OCILobFlushBuffer() + + + + +OCILobEnableBuffering() + +Name +OCI Lob Enable Buffering + +Purpose +Enable lob buffering for the input locator. + + +Syntax +sword OCILobEnableBuffering ( OCISvcCtx *svchp, + OCIError *errhp, + OCILobLocator *locp); + +Comments + +Enable lob buffering for the input locator. The next time data is +read/written from/to the lob through the input locator, the lob +buffering subsystem is used. + +Once lob buffering is enabled for a locator, if that locator is passed to +one of the following routines, an error is returned: + OCILobCopy, OCILobAppend, OCILobErase, OCILobGetLength, OCILobTrim + +Parameters +svchp (IN) - the service context handle. +errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +locp (IN/OUT) - a locator uniquely referencing the LOB. + +Related Functions +OCILobDisableBuffering() +OCIErrorGet() +OCILobWrite() +OCILobRead() +OCILobFlushBuffer() + + + + +OCILobErase() + +Name +OCI Lob ERase + +Purpose +Erases a specified portion of the LOB data starting at a specified offset. + +Syntax +sword OCILobErase ( OCISvcCtx *svchp, + OCIError *errhp, + OCILobLocator *locp, + ub4 *amount, + ub4 offset ); + +Comments +Erases a specified portion of the LOB data starting at a specified offset. +The actual number of characters/bytes erased is returned. The actual number +of characters/bytes and the requested number of characters/bytes will differ +if the end of the LOB data is reached before erasing the requested number of +characters/bytes. +If a section of data from the middle of the LOB data is erased, a hole is +created. When data from that hole is read, 0's are returned. If the LOB is +NULL, this routine will indicate that 0 characters/bytes were erased. + +Parameters +svchp (IN) - the service context handle. +errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +locp (IN/OUT) - the LOB for which to erase a section of data. +amount (IN/OUT) - On IN, the number of characters/bytes to erase. On OUT, +the actual number of characters/bytes erased. +offset (IN) - absolute offset from the beginning of the LOB data from which +to start erasing data. Starts at 1. + +See Also +OCIErrorGet(), OCILobRead(), OCILobWrite() + +OCILobOpen() + +Name +OCI Lob Open + +Purpose +Opens an internal or external Lob. + +Syntax +sword OCILobOpen( OCISvcCtx *svchp, + OCIError *errhp, + OCILobLocator *locp, + ub1 mode ); + +Comments +It is an error if the same lob is opened more than once in +the same transaction. Lobs are opened implicitly if they are +not opened before using them. A LOB has to be closed before +the transaction commits else the transaction is rolled back. +Open locators are closed if the transaction aborts. Multiple +users can open the same lob on different locators. +Parameters +svchp (IN) - the service context handle. +errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +locp (IN/OUT) - locator points to the LOB to be opened +mode (IN) - mode in which to open the lob. The valid modes are +read-only - OCI_FILE_READONLY, read-write - OCI_FILE_READWRITE + +OCILobClose() + +Name +OCI Lob Close + +Purpose +Closes an open internal or external Lob. + +Syntax +sword OCILobClose( OCISvcCtx *svchp, + OCIError *errhp, + OCILobLocator *locp ); + + +Comments +It is an error if the lob is not open at this time. All LOBs +that have been opened in a transaction have to be closed +before the transaction commits, else the transaction gets +rolled back. + +Parameters +svchp (IN) - the service context handle. +errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +locp (IN) - A locator that was opened using OCILobOpen() + + +OCILobFileClose() + +Name +OCI Lob File CLoSe + +Purpose +Closes a previously opened FILE. + +Syntax +sword OCILobFileClose ( OCISvcCtx *svchp, + OCIError *errhp, + OCILobLocator *filep ); + +Comments +Closes a previously opened FILE. It is an error if this function is called for +an internal LOB. No error is returned if the FILE exists but is not opened. +Parameters +svchp (IN) - the service context handle. +errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +filep (IN/OUT) - a pointer to a FILE locator to be closed. + +See Also +OCIErrorGet(), OCILobFileOpen(), OCILobFileCloseAll(), OCILobFileIsOpen(), +OCILobFileExists(), CREATE DIRECTORY DDL + + + + +OCILobFileCloseAll() + +Name +OCI LOB FILE Close All + +Purpose +Closes all open FILEs on a given service context. + +Syntax +sword OCILobFileCLoseAll ( OCISvcCtx *svchp, + OCIError *errhp ); + +Comments +Closes all open FILEs on a given service context. + +Parameters +svchp (IN) - the service context handle. +errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. + +See also +OCILobFileClose(), +OCIErrorGet(), OCILobFileOpen(), OCILobFileIsOpen(), +OCILobFileExists(), CREATE DIRECTORY DDL + + + + +OCILobFileExists() + +Name +OCI LOB FILE exists + +Purpose +Tests to see if the FILE exists on the server + +Syntax +sword OCILobFileExists ( OCISvcCtx *svchp, + OCIError *errhp, + OCILobLocator *filep, + boolean *flag ); + +Comments +Checks to see if a FILE exists for on the server. + +Parameters +svchp (IN) - the OCI service context handle. +errhp (IN/OUT) - error handle. The OCI error handle. If there is an error, +it is recorded in err and this function returns OCI_ERROR. Diagnostic +information can be obtained by calling OCIErrorGet(). +filep (IN) - pointer to the FILE locator that refers to the file. +flag (OUT) - returns TRUE if the FILE exists; FALSE if it does not. + +See also +OCIErrorGet, CREATE DIRECTORY (DDL) + + + + +OCILobFileGetName() + +Name +OCI LOB FILE Get file Name + +Purpose +Gets the FILE locator's directory alias and file name. + +Syntax +sword OCILobFileGetName ( OCIEnv *envhp, + OCIError *errhp, + const OCILobLocator *filep, + OraText *dir_alias, + ub2 *d_length, + OraText *filename, + ub2 *f_length ); + +Comments +Returns the directory alias and file name associated with this file locator. + +Parameters +envhp (IN/OUT) - OCI environment handle initialized in object mode. +errhp (IN/OUT) -The OCI error handle. If there is an error, it is recorded in +errhp and this function returns OCI_ERROR. Diagnostic information can be +obtained by calling OCIErrorGet(). +filep (IN) - FILE locator for which to get the directory alias and file name. +dir_alias (OUT) - buffer into which the directory alias name is placed. The +caller must allocate enough space for the directory alias name and must not +write into the space. +d_length (IN/OUT) + - IN: length of the input dir_alias string; + - OUT: length of the returned dir_alias string. +filename (OUT) - buffer into which the file name is placed. The caller must +allocate enough space for the file name and must not write into the space. +f_length (IN/OUT) + - IN: length of the input filename string; + - OUT: lenght of the returned filename string. + +See also +OCILobFileSetName(), OCIErrorGet() + + + + +OCILobFileIsOpen() + +Name +OCI LOB FILE Is Open? + +Purpose +Tests to see if the FILE is open + +Syntax +sword OCILobFileIsOpen ( OCISvcCtx *svchp, + OCIError *errhp, + OCILobLocator *filep, + boolean *flag ); + +Comments +Checks to see if the FILE on the server is open for a given LobLocator. + +Parameters +svchp (IN) - the OCI service context handle. +errhp (IN/OUT) - error handle. The OCI error handle. If there is an error, it +is recorded in err and this function returns OCI_ERROR. Diagnostic +information can be obtained by calling OCIErrorGet(). +filep (IN) - pointer to the FILE locator being examined. If the input file +locator was never passed to OCILobFileOpen(), the file is considered not to +be opened by this locator. However, a different locator may have opened the +file. More than one file opens can be performed on the same file using +different locators. +flag (OUT) - returns TRUE if the FILE is opened using this locator; FALSE if +it is not. + +See also +OCIErrorGet, OCILobFileOpen, OCILobFileClose, OCILobFileCloseAll, CREATE +DIRECTORY SQL command + + +OCILobFileOpen() + +Name +OCI LOB FILE open + +Purpose +Opens a FILE for read-only access + +Syntax +sword OCILobFileOpen ( OCISvcCtx *svchp, + OCIError *errhp, + OCILobLocator *filep, + ub1 mode ); + +Comments +Opens a FILE. The FILE can be opened for read-only access only. FILEs may not +be written to throough ORACLE. + +Parameters +svchp (IN) - the service context handle. +errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +filep (IN/OUT) - the FILE to open. Error if the locator does not refer to a +FILE. +mode (IN) - mode in which to open the file. The only valid mode is +read-only - OCI_FILE_READONLY. + +See Also +OCILobFileClose, OCIErrorGet, OCILobFileCloseAll, OCILobFileIsOpen, +OCILobFileSetName, CREATE DIRECTORY + + + + +OCILobFileSetName() + +Name +OCI Lob File Set NaMe + +Purpose +Sets directory alias and file name in the FILE locator. + +Syntax +sword OCILobFileSetName ( OCIEnv *envhp, + OCIError *errhp, + OCILobLocator **filepp, + OraText *dir_alias, + ub2 d_length, + OraText *filename, + ub2 f_length ); +Comments +Sets the directory alias and file name in the LOB file locator. +Parameters +envhp (IN/OUT) - OCI environment handle initialized in object mode. +errhp (IN/OUT) - The OCI error handle. If there is an error, it is recorded +in errhp and this function returns OCI_ERROR. Diagnostic information can be +obtained by calling OCIErrorGet(). +filepp (IN/OUT) - FILE locator for which to set the directory alias name. +The caller must have already allocated space for the locator by calling +OCIDescriptorAlloc(). +dir_alias (IN) - buffer that contains the directory alias name to set in the +locator. +d_length (IN) - length of the input dir_alias parameter. +filename (IN) - buffer that contains the file name is placed. +f_length (IN) - length of the input filename parameter. +See also +OCILobFileGetName, OCIErrorGet, CREATE DIRECTORY + + + + +OCILobFlushBuffer() + +Name +OCI Lob Flush all Buffers for this lob. + +Purpose +Flush/write all buffers for this lob to the server. + + +Syntax +sword OCILobFlushBuffer ( OCISvcCtx *svchp, + OCIError *errhp, + OCILobLocator *locp, + ub4 flag); + +Comments + +Flushes to the server, changes made to the buffering subsystem that +are associated with the lob referenced by the input locator. This +routine will actually write the data in the buffer to the lob in +the database. Lob buffering must have already been enabled for the +input lob locator. + +This routine, by default, does not free the buffer resources for +reallocation to another buffered LOB operation. However, if you +want to free the buffer explicitly, you can set the flag parameter +to OCI_LOB_BUFFER_FREE. + +Parameters +svchp (IN/OUT) - the service context handle. +errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +locp (IN/OUT) - a locator uniquely referencing the LOB. +flag (IN) - to indicate if the buffer resources need to be freed + after a flush. Default value is OCI_LOB_BUFFER_NOFREE. + Set it to OCI_LOB_BUFFER_FREE if you want the buffer + resources to be freed. +Related Functions +OCILobEnableBuffering() +OCILobDisableBuffering() +OCIErrorGet() +OCILobWrite() +OCILobRead() + + +OCILobFreeTemporary() + +Name +OCI Lob Free Temporary + +Purpose +Free a temporary LOB + +Syntax +sword OCILobFreeTemporary(OCISvcCtx *svchp, + OCIError *errhp, + OCILobLocator *locp); + +Comments + Frees the contents of the temporary Lob this locator is pointing to. Note + that the locator itself is not freed until a OCIDescriptorFree is done. + +Parameters +svchp (IN/OUT) - the service context handle. +errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +locp (IN/OUT) - a locator uniquely referencing the LOB + +Related functions +OCILobCreateTemporary() +OCILobIsTemporary() + + +Name +OCI Lob/File Get Chunk Size + +Purpose +When creating the table, the user can specify the chunking factor, which can +be a multiple of Oracle blocks. This corresponds to the chunk size used by the +LOB data layer when accessing/modifying the LOB value. Part of the chunk is +used to store system-related information and the rest stores the LOB value. +This function returns the amount of space used in the LOB chunk to store +the LOB value. + +Syntax +sword OCILobGetChunkSize ( OCISvcCtx *svchp, + OCIError *errhp, + OCILobLocator *locp, + ub4 *chunksizep ); + +Comments + Performance will be improved if the user issues read/write +requests using a multiple of this chunk size. For writes, there is an added +benefit since LOB chunks are versioned and, if all writes are done on chunk +basis, no extra/excess versioning is done nor duplicated. Users could batch +up the write until they have enough for a chunk instead of issuing several +write calls for the same chunk. + +Parameters +svchp (IN) - the service context handle. +errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +locp (IN/OUT) - a LOB locator that uniquely references the LOB. For internal +LOBs, this locator must be a locator that was obtained from the server +specified by svchp. For FILEs, this locator can be initialized by a Select or +OCILobFileSetName. +chunksizep (OUT) - On output, it is the length of the LOB if not NULL - for +character LOBs it is the number of characters, for binary LOBs it is the +number of bytes in the LOB. + +Related Functions + +OCILobGetLength() + +Name +OCI Lob/File Length + +Purpose +Gets the length of a LOB/FILE. + +Syntax +sword OCILobGetLength ( OCISvcCtx *svchp, + OCIError *errhp, + OCILobLocator *locp, + ub4 *lenp ); + +Comments +Gets the length of a LOB/FILE. If the LOB/FILE is NULL, the length is +undefined. + +Parameters +svchp (IN) - the service context handle. +errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +locp (IN/OUT) - a LOB locator that uniquely references the LOB. For internal +LOBs, this locator must be a locator that was obtained from the server +specified by svchp. For FILEs, this locator can be initialized by a Select or +OCILobFileSetName. +lenp (OUT) - On output, it is the length of the LOB if not NULL - for +character LOBs it is the number of characters, for binary LOBs it is the +number of bytes in the LOB. + +Related Functions +OCIErrorGet, OCIFileSetName + + + +OCILobIsEqual() + +Name + +OCI Lob Is Equal + +Purpose +Compares two LOB locators for equality. + +Syntax +sword OCILobIsEqual ( OCIEnv *envhp, + const OCILobLocator *x, + const OCILobLocator *y, + boolean *is_equal ); + +Comments +Compares the given LOB locators for equality. Two LOB locators are equal if +and only if they both refer to the same LOB data. +Two NULL locators are considered not equal by this function. +Parameters +envhp (IN) - the OCI environment handle. +x (IN) - LOB locator to compare. +y (IN) - LOB locator to compare. +is_equal (OUT) - TRUE, if the LOB locators are equal; FALSE if they are not. + +See also +OCILobAssign, OCILobLocatorIsInit +OCILobLocatorAssign, +OCILobIsOpen() + +Name + +OCI Lob Is Open +sword OCILobIsOpen(svchp, errhp, locp, flag) +OCISvcCtx *svchp; +OCIError *errhp; +OCILobLocator *locp; +boolean *flag; + +Comments + Checks if the LOB locator was opened before. flag is set to TRUE + if opened; FALSE otherwise + + +Parameters +svchp (IN) - the service context handle. +errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +locp (IN) - the locator to test for temporary LOB +flag(OUT) - TRUE, if the LOB locator points to is open + FALSE, if not. + +OCILobIsTemporary() + +Name + +OCI Lob Is Temporary + +Purpose + Tests if this locator points to a temporary LOB + +Syntax +sword OCILobIsTemporary(OCIEnv *envhp, + OCIError *errhp, + OCILobLocator *locp, + boolean *is_temporary); + +Comments +Tests the locator to determine if it points to a temporary LOB. +If so, is_temporary is set to TRUE. If not, is_temporary is set +to FALSE. + +Parameters +envhp (IN) - the environment handle. +errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +locp (IN) - the locator to test for temporary LOB +is_temporary(OUT) - TRUE, if the LOB locator points to a temporary LOB; + FALSE, if not. + +See Also +OCILobCreateTemporary, OCILobFreeTemporary + + +OCILobLoadFromFile() + +Name +OCI Lob Load From File + +Purpose +Load/copy all or a portion of the file into an internal LOB. + +Syntax +sword OCILobLoadFromFile ( OCISvcCtx *svchp, + OCIError *errhp, + OCILobLocator *dst_locp, + OCILobLocator *src_filep, + ub4 amount, + ub4 dst_offset, + ub4 src_offset ); + +Comments +Loads/copies a portion or all of a file value into an internal LOB as +specified. The data is copied from the source file to the destination +internal LOB (BLOB/CLOB). No character set conversions are performed +when copying the bfile data to a clob/nclob. The bfile data must already +be in the same character set as the clob/nclob in the database. No +error checking is performed to verify this. +The source (src_filep) and the destination (dst_locp) LOBs must already exist. +If the data already exists at the destination's start position, it is +overwritten with the source data. If the destination's start position is +beyond the end of the current data, a hole is created from the end of the data +to the beginning of the newly written data from the source. The destination +LOB is extended to accommodate the newly written data if it extends +beyond the current length of the destination LOB. +It is an error to extend the destination LOB beyond the maximum length +allowed or to try to copy from a NULL LOB. +Parameters +svchp (IN) - the service context handle. +errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +dst_locp (IN/OUT) - a locator uniquely referencing the destination internal +LOB which may be of type blob, clob, or nclob. +src_filep (IN/OUT) - a locator uniquely referencing the source BFILE. +amount (IN) - the number of bytes to be copied. +dst_offset (IN) - this is the absolute offset for the destination LOB. +For character LOBs it is the number of characters from the beginning of the +LOB at which to begin writing. For binary LOBs it is the number of bytes from +the beginning of the lob from which to begin reading. The offset starts at 1. +src_offset (IN) - this is the absolute offset for the source BFILE. It is +the number of bytes from the beginning of the LOB. The offset starts at 1. + +See Also +OCIErrorGet(), OCILobAppend(), OCILobWrite(), OCILobTrim(), OCILobCopy() + +OCILobLocatorAssign() + +Name +OCI Lob LOCATOR ASsiGn + +Purpose +Assigns one LOB/FILE locator to another. + +Syntax +sword OCILobLocatorAssign ( OCISvcCtx *svchp, + OCIError *errhp, + const OCILobLocator *src_locp, + OCILobLocator **dst_locpp ); + +Comments +Assign source locator to destination locator. After the assignment, both +locators refer to the same LOB data. For internal LOBs, the source locator's +LOB data gets copied to the destination locator's LOB data only when the +destination locator gets stored in the table. Therefore, issuing a flush of +the object containing the destination locator will copy the LOB data. For +FILEs only the locator that refers to the OS file is copied to the table. The +OS file is not copied. +Note : the only difference between this and OCILobAssign is that this takes +a OCI service handle pointer instead of a OCI environment handle pointer + +Parameters +svchp (IN/OUT) - OCI service handle initialized in object mode. +errhp (IN/OUT) - The OCI error handle. If there is an error, it is recorded +in errhp and this function returns OCI_ERROR. Diagnostic information can be +obtained by calling OCIErrorGet(). +src_locp (IN) - LOB locator to copy from. +dst_locpp (IN/OUT) - LOB locator to copy to. The caller must allocate space +for the OCILobLocator by calling OCIDescriptorAlloc(). + +See also +OCIErrorGet() +OCILobIsEqual() +OCILobLocatorIsInit() +OCILobAssign() + + + + +OCILobLocatorIsInit() + +Name +OCI LOB locator is initialized? + +Purpose +Tests to see if a given LOB locator is initialized. + +Syntax +sword OCILobLocatorIsInit ( OCIEnv *envhp, + OCIError *errhp, + const OCILobLocator *locp, + boolean *is_initialized ); + +Comments +Tests to see if a given LOB locator is initialized. + +Parameters +envhp (IN/OUT) - OCI environment handle initialized in object mode. +errhp (IN/OUT) - error handle. The OCI error handle. If there is an error, it +is recorded in err and this function returns OCI_ERROR. Diagnostic +information can be obtained by calling OCIErrorGet(). +locp (IN) - the LOB locator being tested +is_initialized (OUT) - returns TRUE if the given LOB locator is initialized; +FALSE if it is not. + +See also +OCIErrorGet, OCILobIsEqual + + + + +OCILobRead() + +Name +OCI Lob/File ReaD + +Purpose +Reads a portion of a LOB/FILE as specified by the call into a buffer. + +Syntax +sword OCILobRead ( OCISvcCtx *svchp, + OCIError *errhp, + OCILobLocator *locp, + ub4 offset, + ub4 *amtp, + void *bufp, + ub4 bufl, + void *ctxp, + OCICallbackLobRead cbfp, + ub2 csid, + ub1 csfrm ); + +Comments +Reads a portion of a LOB/FILE as specified by the call into a buffer. Data +read from a hole is returned as 0s. It is an error to try to read from a NULL +LOB/FILE. The OS FILE must already exist on the server and must have been +opened using the input locator. Oracle must hav epermission to read the OS +file and user must have read permission on the directory object. + +Parameters +svchp (IN/OUT) - the service context handle. +errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +locp (IN/OUT) - a LOB locator that uniquely references a LOB. +offset (IN) - On input, it is the absolute offset, for character LOBs in the +number of characters from the beginning of the LOB, for binary LOBs it is the +number of bytes. Starts from 1. +amtp (IN/OUT) - On input, the number of character or bytes to be read. On +output, the actual number of bytes or characters read. +If the amount of bytes to be read is larger than the buffer length it is +assumed that the LOB is being read in a streamed mode. On input if this value +is 0, then the data shall be read in streamed mode from the LOB until the end +of LOB. If the data is read in pieces, *amtp always contains the length of +the last piece read. If a callback function is defined, then this callback +function will be invoked each time bufl bytes are read off the pipe. Each +piece will be written into bufp. +If the callback function is not defined, then OCI_NEED_DATA error code will +be returned. The application must invoke the LOB read over and over again to +read more pieces of the LOB until the OCI_NEED_DATA error code is not +returned. The buffer pointer and the length can be different in each call +if the pieces are being read into different sizes and location. +bufp (IN) - the pointer to a buffer into which the piece will be read. The +length of the allocated memory is assumed to be bufl. +bufl (IN) - the length of the buffer in octets. +ctxp (IN) - the context for the call back function. Can be NULL. +cbfp (IN) - a callback that may be registered to be called for each piece. If +this is NULL, then OCI_NEED_DATA will be returned for each piece. +The callback function must return OCI_CONTINUE for the read to continue. +If any other error code is returned, the LOB read is aborted. + ctxp (IN) - the context for the call back function. Can be NULL. + bufp (IN) - a buffer pointer for the piece. + len (IN) - the length of length of current piece in bufp. + piece (IN) - which piece - OCI_FIRST_PIECE, OCI_NEXT_PIECE or + OCI_LAST_PIECE. +csid - the character set ID of the buffer data +csfrm - the character set form of the buffer data + +Related Functions +OCIErrorGet, OCILobWrite, OCILobFileOpen, OCILobFileSetName, CREATE DIRECTORY + + + + +OCILobTrim() + +Name + +OCI Lob Trim + +Purpose +Trims the lob value to a shorter length + +Syntax +sword OCILobTrim ( OCISvcCtx *svchp, + OCIError *errhp, + OCILobLocator *locp, + ub4 newlen ); + +Comments +Truncates LOB data to a specified shorter length. + +Parameters +svchp (IN) - the service context handle. +errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +locp (IN/OUT) - a LOB locator that uniquely references the LOB. This locator +must be a locator that was obtained from the server specified by svchp. +newlen (IN) - the new length of the LOB data, which must be less than or equal +to the current length. + +Related Functions +OCIErrorGet, OCILobWrite, OCiLobErase, OCILobAppend, OCILobCopy + + + + + +OCILobWrite() + +Name +OCI Lob Write + +Purpose +Writes a buffer into a LOB + +Syntax +sword OCILobWrite ( OCISvcCtx *svchp, + OCIError *errhp, + OCILobLocator *locp, + ub4 offset, + ub4 *amtp, + void *bufp, + ub4 buflen, + ub1 piece, + void *ctxp, + OCICallbackLobWrite (cbfp) + ( + void *ctxp, + void *bufp, + ub4 *lenp, + ub1 *piecep ) + ub2 csid + ub1 csfrm ); + + +Comments +Writes a buffer into a LOB as specified. If LOB data already exists +it is overwritten with the data stored in the buffer. +The buffer can be written to the LOB in a single piece with this call, or +it can be provided piecewise using callbacks or a standard polling method. +If this value of the piece parameter is OCI_FIRST_PIECE, data must be +provided through callbacks or polling. +If a callback function is defined in the cbfp parameter, then this callback +function will be invoked to get the next piece after a piece is written to +the pipe. Each piece will be written from bufp. +If no callback function is defined, then OCILobWrite() returns the +OCI_NEED_DATA error code. The application must all OCILobWrite() again +to write more pieces of the LOB. In this mode, the buffer pointer and the +length can be different in each call if the pieces are of different sizes and +from different locations. A piece value of OCI_LAST_PIECE terminates the +piecewise write. + +Parameters +svchp (IN/OUT) - the service context handle. +errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +locp (IN/OUT) - a LOB locator that uniquely references a LOB. +offset (IN) - On input, it is the absolute offset, for character LOBs in +the number of characters from the beginning of the LOB, for binary LOBs it +is the number of bytes. Starts at 1. +bufp (IN) - the pointer to a buffer from which the piece will be written. The +length of the allocated memory is assumed to be the value passed in bufl. +Even if the data is being written in pieces, bufp must contain the first +piece of the LOB when this call is invoked. +bufl (IN) - the length of the buffer in bytes. +Note: This parameter assumes an 8-bit byte. If your platform uses a +longer byte, the value of bufl must be adjusted accordingly. +piece (IN) - which piece of the buffer is being written. The default value for +this parameter is OCI_ONE_PIECE, indicating the buffer will be written in a +single piece. +The following other values are also possible for piecewise or callback mode: +OCI_FIRST_PIECE, OCI_NEXT_PIECE and OCI_LAST_PIECE. +amtp (IN/OUT) - On input, takes the number of character or bytes to be +written. On output, returns the actual number of bytes or characters written. +If the data is written in pieces, *amtp will contain the total length of the +pieces written at the end of the call (last piece written) and is undefined in +between. +(Note it is different from the piecewise read case) +ctxp (IN) - the context for the call back function. Can be NULL. +cbfp (IN) - a callback that may be registered to be called for each piece in +a piecewise write. If this is NULL, the standard polling method will be used. +The callback function must return OCI_CONTINUE for the write to continue. +If any other error code is returned, the LOB write is aborted. The +callback takes the following parameters: + ctxp (IN) - the context for the call back function. Can be NULL. + bufp (IN/OUT) - a buffer pointer for the piece. + lenp (IN/OUT) - the length of the buffer (in octets) and the length of + current piece in bufp (out octets). + piecep (OUT) - which piece - OCI_NEXT_PIECE or OCI_LAST_PIECE. +csid - the character set ID of the buffer data +csfrm - the character set form of the buffer data +Related Functions + +OCILobWriteAppend() + +Name +OCI Lob Write Append + +Purpose +Writes data to the end of a LOB value. This call provides the ability +to get the length of the data and append it to the end of the LOB in +a single round trip to the server. + +Syntax +sword OCILobWriteAppend ( OCISvcCtx *svchp, + OCIError *errhp, + OCILobLocator *locp, + ub4 *amtp, + void *bufp, + ub4 buflen, + ub1 piece, + void *ctxp, + OCICallbackLobWrite (cbfp) + ( + void *ctxp, + void *bufp, + ub4 *lenp, + ub1 *piecep ) + ub2 csid + ub1 csfrm ); + + +Comments +Writes a buffer to the end of a LOB as specified. If LOB data already exists +it is overwritten with the data stored in the buffer. +The buffer can be written to the LOB in a single piece with this call, or +it can be provided piecewise using callbacks or a standard polling method. +If this value of the piece parameter is OCI_FIRST_PIECE, data must be +provided through callbacks or polling. +If a callback function is defined in the cbfp parameter, then this callback +function will be invoked to get the next piece after a piece is written to the +pipe. Each piece will be written from bufp. +If no callback function is defined, then OCILobWriteAppend() returns the +OCI_NEED_DATA error code. The application must all OCILobWriteAppend() again +to write more pieces of the LOB. In this mode, the buffer pointer and the +length can be different in each call if the pieces are of different sizes and +from different locations. A piece value of OCI_LAST_PIECE terminates the +piecewise write. + +Parameters +svchp (IN/OUT) - the service context handle. +errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +locp (IN/OUT) - a LOB locator that uniquely references a LOB. +bufp (IN) - the pointer to a buffer from which the piece will be written. The +length of the allocated memory is assumed to be the value passed in bufl. Even +if the data is being written in pieces, bufp must contain the first piece of +the LOB when this call is invoked. +bufl (IN) - the length of the buffer in bytes. +Note: This parameter assumes an 8-bit byte. If your platform uses a +longer byte, the value of bufl must be adjusted accordingly. +piece (IN) - which piece of the buffer is being written. The default value for +this parameter is OCI_ONE_PIECE, indicating the buffer will be written in a +single piece. +The following other values are also possible for piecewise or callback mode: +OCI_FIRST_PIECE, OCI_NEXT_PIECE and OCI_LAST_PIECE. +amtp (IN/OUT) - On input, takes the number of character or bytes to be +written. On output, returns the actual number of bytes or characters written. +If the data is written in pieces, *amtp will contain the total length of the +pieces written at the end of the call (last piece written) and is undefined in +between. +(Note it is different from the piecewise read case) +ctxp (IN) - the context for the call back function. Can be NULL. +cbfp (IN) - a callback that may be registered to be called for each piece in a +piecewise write. If this is NULL, the standard polling method will be used. +The callback function must return OCI_CONTINUE for the write to continue. +If any other error code is returned, the LOB write is aborted. The +callback takes the following parameters: + ctxp (IN) - the context for the call back function. Can be NULL. + bufp (IN/OUT) - a buffer pointer for the piece. + lenp (IN/OUT) - the length of the buffer (in octets) and the length of + current piece in bufp (out octets). + piecep (OUT) - which piece - OCI_NEXT_PIECE or OCI_LAST_PIECE. +csid - the character set ID of the buffer data +csfrm - the character set form of the buffer data +Related Functions + + + + +OCILobGetStorageLimit() + +Name +OCI Lob Get Storage Limit + +Purpose +To get the maximum Length of a LOB in bytes that can be stored in the database. + +Syntax +sword OCILobGetStorageLimit ( OCISvcCtx *svchp, + OCIError *errhp, + OCILobLocator *locp, + oraub8 *limitp); + + +Comments +With unlimited size LOB support the limit for a LOB is no longer restricted +to 4GB. +This interface should be used to get the actual limit for storing data for +a specific +LOB locator. Note that if the compatibality is set to 9.2 or older the limit +would still be 4GB. + +Parameters +svchp (IN/OUT) - the service context handle. +errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +locp (IN/OUT) - a LOB locator that uniquely references a LOB. +limitp (OUT) - The storage limit for a LOB in bytes. +Related Functions + + + + +OCILobGetOptions() + +Name +OCI Lob Get Options + +Purpose +To get the current options set for the given SecureFile. + +Syntax +sword OCILobGetOptions ( OCISvcCtx *svchp, + OCIError *errhp, + OCILobLocator *locp, + ub4 optypes, + void *optionsp, + ub4 *optionslenp, + ub4 mode); + + +Comments +This function only works on SecureFiles. All others will get an error. + +Parameters +svchp (IN/OUT) - the service context handle. +errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +locp (IN/OUT) - a LOB locator that uniquely references a LOB. +optypes (IN) - the types of options flags to be retrieved. +optionsp (OUT) - the options flags or value for the given types. +optionslenp (IN/OUT) - the length of option_value buffer +mode (IN) - for future use (pass 0 for now). +Related Functions +OCISetOptions() + +OCILobSetOptions() + +Name +OCI Lob Set Options + +Purpose +To set the options for the given SecureFile Lob. + +Syntax +sword OCILobSetOptions ( OCISvcCtx *svchp, + OCIError *errhp, + OCILobLocator *locp, + ub4 optypes, + void *optionsp, + ub4 optionslen, + ub4 mode); + + +Comments +This function only works on SecureFile Lobs. All others will get an error. + +Parameters +svchp (IN/OUT) - the service context handle. +errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +locp (IN/OUT) - a LOB locator that uniquely references a LOB. +optypes (IN) - the types of options flags to be set. +optionsp (IN) - the options flags or value to be set for the given types. +optionslen (IN) - then length of option_value buffer +mode (IN) - for future use (pass 0 for now). +Related Functions +OCILobGetOptions() + +OCILobGetContentType() + +Name +OCI Lob Get Content Type + +Purpose +To get the current contenttype set for the given SecureFile. + +Syntax +sword OCILobGetContentType (OCISvcCtx *svchp, + OCIError *errhp, + OCILobLocator *locp, + oratext *contenttypep, + ub4 *contenttypelenp, + ub4 mode); + + +Comments +This function only works on SecureFiles. All others will get an error. +If the securefile does not have a contenttype associated with it, +the contenttype length (= *contenttypelenp) is returned as 0 without +modifying the buffer contenttypep. +Parameters +svchp (IN/OUT) - the service context handle. +errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for + diagnostic information in the event of an error. +locp (IN/OUT) - a LOB locator that uniquely references a LOB. +contenttypep(IN/OUT)- pointer to the buffer where the contenttype is stored + after successful execution. + The caller needs to allocate the buffer before calling + this function. The size of the allocated buffer should + be >= OCI_LOB_CONTENTTYPE_MAXSIZE bytes +contenttypelenp(IN/OUT)- The caller should set this field to the size + of contenttypep buffer. + After the call successfully executes, it will hold the + size of the contenttype returned. +mode (IN) - for future use (pass 0 for now). +Related Functions +OCISetContentType() + +OCILobSetContentType() + +Name +OCI Lob Set Content Type + +Purpose +To set the contenttype for the given SecureFile Lob. + +Syntax +sword OCILobSetContentType (OCISvcCtx *svchp, + OCIError *errhp, + OCILobLocator *locp, + const oratext *contenttypep, + ub4 contenttypelen, + ub4 mode); + + +Comments +This function only works on SecureFiles. All others will get an error. +To clear an existing contenttype set on a securefile, the user will +invoke OCILobSetContentType API with contenttypep set to (oratext *)0, +and contenttypelen set to 0. +Parameters +svchp (IN/OUT) - the service context handle. +errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +locp (IN/OUT) - a LOB locator that uniquely references a LOB. +contenttypep (IN) - the contenttype to be set for the given LOB. +contenttypelen(IN) - the size of contenttype in bytes. The size of the + contenttype should be <= OCI_LOB_CONTENTTYPE_MAXSIZE + bytes. +mode (IN) - for future use (pass 0 for now). +Related Functions +OCILobGetContentType() + + +OCILogoff() +Name +OCI simplified Logoff +Purpose +This function is used to terminate a session created with OCILogon() or +OCILogon2(). +Syntax +sword OCILogoff ( OCISvcCtx *svchp + OCIError *errhp ); +Comments +This call is used to terminate a session which was created with OCILogon() or +OCILogon2(). +This call implicitly deallocates the server, authentication, and service +context handles. +Note: For more information on logging on and off in an application, +refer to the section "Application Initialization, Connection, and +Authorization" on page 2-16. +Parameters +svchp (IN) - the service context handle which was used in the call to +OCILogon() or OCILogon2(). +errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +See Also +OCILogon(), OCILogon2(). + + + + + + +OCILogon() +Name +OCI Service Context Logon +Purpose +This function is used to create a simple logon session. +Syntax +sword OCILogon ( OCIEnv *envhp, + OCIError *errhp, + OCISvcCtx *svchp, + const OraText *username, + ub4 uname_len, + const OraText *password, + ub4 passwd_len, + const OraText *dbname, + ub4 dbname_len ); +Comments +This function is used to create a simple logon session for an application. +Note: Users requiring more complex session (e.g., TP monitor +applications) should refer to the section "Application Initialization, +Connection, and Authorization" on page 2-16. +This call allocates the error and service context handles which are passed to +it. This call also implicitly allocates server and authentication handles +associated with the session. These handles can be retrieved by calling +OCIAttrGet() on the service context handle. +Parameters +envhp (IN) - the OCI environment handle. +errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +svchp (OUT) - the service context pointer. +username (IN) - the username. +uname_len (IN) - the length of username. +password (IN) - the user's password. +passwd_len (IN) - the length of password. +dbname (IN) - the name of the database to connect to. +dbname_len (IN) - the length of dbname. +See Also +OCILogoff() + + + + + +OCILogon2() +Name +OCI Service Context Logon +Purpose +This function is used to create a logon session in connection pooling mode. +Syntax +sword OCILogon2 ( OCIEnv *envhp, + OCIError *errhp, + OCISvcCtx **svchp, + const OraText *username, + ub4 uname_len, + const OraText *password, + ub4 passwd_len, + const OraText *dbname, + ub4 dbname_len, + ub4 mode); +Comments +This function is used to create a simple logon session for an application in +Connection Pooling mode. The valid values for mode are currently OCI_POOL and +OCI_DEFAULT. Call to this function with OCI_DEFAULT mode is equivalent to +OCILogon() call. +This call allocates the error and service context handles which are passed to +it. This call also implicitly allocates server and authentication handles +associated with the session. These handles can be retrieved by calling +OCIAttrGet() on the service context handle. This call assumes that +OCIConnectionPoolCreate() has already been called for the same dbname. +Parameters +envhp (IN) - the OCI environment handle. +errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +svchp (OUT) - the service context pointer. +username (IN) - the username. +uname_len (IN) - the length of username. +password (IN) - the user's password. If this is null, it is assumed that a + proxy session has to be created and the required grants on + the database are already done. +passwd_len (IN) - the length of password. +dbname (IN) - the name of the database to connect to. +dbname_len (IN) - the length of dbname. +mode (IN) - the mode for doing the server attach. Should be OCI_POOL for + using Connection Pooling. + + +See Also +OCILogoff() + + + + + +OCIMemoryFree() +Name +OCI FREE Memory +Purpose +Frees up storage associated with the pointer. +Syntax +void OCIMemoryFree ( const OCIStmt *stmhp, + void *memptr); +Comments +Frees up dynamically allocated data pointers associated with the pointer using +either the default memory free function or the registered memory free +function, as the case may be. +A user-defined memory free function can be registered during the initial call +to OCIInitialize(). +This call is always successful. +Parameters +stmhp (IN) - statement handle which returned this data buffer. +memptr (IN) - pointer to data allocated by the client library. +Related Functions +OCIInitialize() + + + + + +OCIParamGet() +Name +OCI Get PARaMeter +Purpose +Returns a descriptor of a parameter specified by position in the describe +handle or statement handle. +Syntax +sword OCIParamGet ( const void *hndlp, + ub4 htype, + OCIError *errhp, + void **parmdpp, + ub4 pos ); +Comments +This call returns a descriptor of a parameter specified by position in the +describe handle or statement handle. Parameter descriptors are always +allocated internally by the OCI library. They are read-only. +OCI_NO_DATA may be returned if there are no parameter descriptors for this +position. +See Appendix B for more detailed information about parameter descriptor +attributes. +Parameters +hndlp (IN) - a statement handle or describe handle. The OCIParamGet() +function will return a parameter descriptor for this handle. +htype (IN) - the type of the handle passed in the handle parameter. Valid +types are OCI_HTYPE_DESCRIBE, for a describe handle OCI_HTYPE_STMT, for a +statement handle +errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +parmdpp (OUT) - a descriptor of the parameter at the position given in the pos +parameter. +pos (IN) - position number in the statement handle or describe handle. A +parameter descriptor will be returned for this position. +Note: OCI_NO_DATA may be returned if there are no parameter +descriptors for this position. +Related Functions +OCIAttrGet(), OCIAttrSet() + + + + + +OCIParamSet() +Name +OCI Parameter Set in handle +Purpose +Used to set a complex object retrieval descriptor into a complex object +retrieval handle. +Syntax +sword OCIParamGet ( void *hndlp, + ub4 htyp, + OCIError *errhp, + const void *dscp, + ub4 dtyp, + ub4 pos ); +Comments +This call sets a given complex object retrieval descriptor into a complex +object retrieval handle. +The handle must have been previously allocated using OCIHandleAlloc(), and +the descriptor must have been previously allocated using OCIDescAlloc(). +Attributes of the descriptor are set using OCIAttrSet(). +Parameters +hndlp (IN/OUT) - handle pointer. +htype (IN) - handle type. +errhp (IN/OUT) - error handle. +dscp (IN) - complex object retrieval descriptor pointer. +dtyp (IN) - +pos (IN) - position number. +See Also + + + + + +OCIPasswordChange() +Name +OCI Change PassWord +Purpose +This call allows the password of an account to be changed. +Syntax +sword OCIPasswordChange ( OCISvcCtx *svchp, + OCIError *errhp, + const OraText *user_name, + ub4 usernm_len, + const OraText *opasswd, + ub4 opasswd_len, + const OraText *npasswd, + sb4 npasswd_len, + ub4 mode); +Comments +This call allows the password of an account to be changed. This call is +similar to OCISessionBegin() with the following differences: +If the user authentication is already established, it authenticates +the account using the old password and then changes the +password to the new password +If the user authentication is not established, it establishes a user +authentication and authenticates the account using the old +password, then changes the password to the new password. +This call is useful when the password of an account is expired and +OCISessionBegin() returns an error or warning which indicates that the +password has expired. +Parameters +svchp (IN/OUT) - a handle to a service context. The service context handle +must be initialized and have a server context handle associated with it. +errhp (IN) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +user_name (IN) - specifies the user name. It points to a character string, +whose length is specified in usernm_len. This parameter must be NULL if the +service context has been initialized with an authentication handle. +usernm_len (IN) - the length of the user name string specified in user_name. +For a valid user name string, usernm_len must be non-zero. +opasswd (IN) - specifies the user's old password. It points to a character +string, whose length is specified in opasswd_len . +opasswd_len (IN) - the length of the old password string specified in opasswd. +For a valid password string, opasswd_len must be non-zero. +npasswd (IN) - specifies the user's new password. It points to a character +string, whose length is specified in npasswd_len which must be non-zero for a +valid password string. If the password complexity verification routine is +specified in the user's profile to verify the new password's complexity, the +new password must meet the complexity requirements of the verification +function. +npasswd_len (IN) - then length of the new password string specified in +npasswd. For a valid password string, npasswd_len must be non-zero. +mode - pass as OCI_DEFAULT. +Related Functions +OCISessionBegin() + + +----------------------------------OCIReset------------------------------------ + + +OCIReset() +Name +OCI Reset +Purpose +Resets the interrupted asynchronous operation and protocol. Must be called +if a OCIBreak call had been issued while a non-blocking operation was in +progress. +Syntax +sword OCIReset ( void *hndlp, + OCIError *errhp); +Comments +This call is called in non-blocking mode ONLY. Resets the interrupted +asynchronous operation and protocol. Must be called if a OCIBreak call +had been issued while a non-blocking operation was in progress. +Parameters +hndlp (IN) - the service context handle or the server context handle. +errhp (IN) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +Related Functions + + +OCIResultSetToStmt() +Name +OCI convert Result Set to Statement Handle +Purpose +Converts a descriptor to statement handle for fetching rows. +Syntax +sword OCIResultSetToStmt ( OCIResult *rsetdp, + OCIError *errhp ); +Comments +Converts a descriptor to statement handle for fetching rows. +A result set descriptor can be allocated with a call to OCIDescAlloc(). +Parameters +rsetdp (IN/OUT) - a result set descriptor pointer. +errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +Related Functions +OCIDescAlloc() + + + + +OCIServerAttach() +Name +OCI ATtaCH to server +Purpose +Creates an access path to a data source for OCI operations. +Syntax +sword OCIServerAttach ( OCIServer *srvhp, + OCIError *errhp, + const OraText *dblink, + sb4 dblink_len, + ub4 mode); +Comments +This call is used to create an association between an OCI application and a +particular server. +This call initializes a server context handle, which must have been previously +allocated with a call to OCIHandleAlloc(). +The server context handle initialized by this call can be associated with a +service context through a call to OCIAttrSet(). Once that association has been +made, OCI operations can be performed against the server. +If an application is operating against multiple servers, multiple server +context handles can be maintained. OCI operations are performed against +whichever server context is currently associated with the service context. +Parameters +srvhp (IN/OUT) - an uninitialized server context handle, which gets +initialized by this call. Passing in an initialized server handle causes an +error. +errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +dblink (IN) - specifies the database (server) to use. This parameter points to +a character string which specifies a connect string or a service point. If the +connect string is NULL, then this call attaches to the default host. The length +of connstr is specified in connstr_len. The connstr pointer may be freed by the +caller on return. +dblink_len (IN) - the length of the string pointed to by connstr. For a valid +connect string name or alias, connstr_len must be non-zero. +mode (IN) - specifies the various modes of operation. For release 8.0, pass as +OCI_DEFAULT - in this mode, calls made to the server on this server context +are made in blocking mode. +Example +See the description of OCIStmtPrepare() on page 13-96 for an example showing +the use of OCIServerAttach(). +Related Functions +OCIServerDetach() + + + +OCIServerDetach() +Name +OCI DeTaCH server +Purpose +Deletes an access to a data source for OCI operations. +Syntax +sword OCIServerDetach ( OCIServer *svrhp, + OCIError *errhp, + ub4 mode); +Comments +This call deletes an access to data source for OCI operations, which was +established by a call to OCIServerAttach(). +Parameters +srvhp (IN) - a handle to an initialized server context, which gets reset to +uninitialized state. The handle is not de-allocated. +errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +mode (IN) - specifies the various modes of operation. The only valid mode is +OCI_DEFAULT for the default mode. +Related Functions +OCIServerAttach() + + + +OCIServerVersion() +Name +OCI VERSion +Purpose +Returns the version string of the Oracle server. +Syntax +sword OCIServerVersion ( void *hndlp, + OCIError *errhp, + OraText *bufp, + ub4 bufsz + ub1 hndltype ); +Comments +This call returns the version string of the Oracle server. +For example, the following might be returned as the version string if your +application is running against a 7.3.2 server: +Oracle7 Server Release 7.3.2.0.0 - Production Release +PL/SQL Release 2.3.2.0.0 - Production +CORE Version 3.5.2.0.0 - Production +TNS for SEQUENT DYNIX/ptx: Version 2.3.2.0.0 - Production +NLSRTL Version 3.2.2.0.0 - Production + +Parameters +hndlp (IN) - the service context handle or the server context handle. +errhp (IN) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +bufp (IN) - the buffer in which the version information is returned. +bufsz (IN) - the length of the buffer. +hndltype (IN) - the type of handle passed to the function. +Related Functions + + + + + +OCISessionBegin() +Name +OCI Session Begin and authenticate user +Purpose +Creates a user authentication and begins a user session for a given server. +Syntax +sword OCISessionBegin ( OCISvcCtx *svchp, + OCIError *errhp, + OCISession *usrhp, + ub4 credt, + ub4 mode); + +Comments +For Oracle8, OCISessionBegin() must be called for any given server handle +before requests can be made against it. Also, OCISessionBegin() only supports +authenticating the user for access to the Oracle server specified by the +server handle in the service context. In other words, after OCIServerAttach() +is called to initialize a server handle, OCISessionBegin() must be called to +authenticate the user for that given server. +When OCISessionBegin() is called for the first time for the given server +handle, the initialized authentication handle is called a primary +authentication context. A primary authentication context may not be created +with the OCI_MIGRATE mode. Also, only one primary authentication context can +be created for a given server handle and the primary authentication context c +an only ever be used with that server handle. If the primary authentication +context is set in a service handle with a different server handle, then an +error will result. +After OCISessionBegin() has been called for the server handle, and the primary +authentication context is set in the service handle, OCISessionBegin() may be +called again to initialize another authentication handle with different (or +the same) credentials. When OCISessionBegin() is called with a service handle +set with a primary authentication context, the returned authentication context +in authp is called a user authentication context. As many user authentication +contexts may be initialized as desired. +User authentication contexts may be created with the OCI_MIGRATE mode. +If the OCI_MIGRATE mode is not specified, then the user authentication +context can only ever be used with the same server handle set in svchp. If +OCI_MIGRATE mode is specified, then the user authentication may be set +with different server handles. However, the user authentication context is +restricted to use with only server handles which resolve to the same database +instance and that have equivalent primary authentication contexts. Equivalent +authentication contexts are those which were authenticated as the same +database user. +OCI_SYSDBA, OCI_SYSOPER, OCI_SYSASM, and OCI_PRELIM_AUTH may only be used +with a primary authentication context. +To provide credentials for a call to OCISessionBegin(), one of two methods are +supported. The first is to provide a valid username and password pair for +database authentication in the user authentication handle passed to +OCISessionBegin(). This involves using OCIAttrSet() to set the +OCI_ATTR_USERNAME and OCI_ATTR_PASSWORD attributes on the +authentication handle. Then OCISessionBegin() is called with +OCI_CRED_RDBMS. +Note: When the authentication handle is terminated using +OCISessionEnd(), the username and password attributes remain +unchanged and thus can be re-used in a future call to OCISessionBegin(). +Otherwise, they must be reset to new values before the next +OCISessionBegin() call. +The second type of credentials supported are external credentials. No +attributes need to be set on the authentication handle before calling +OCISessionBegin(). The credential type is OCI_CRED_EXT. This is equivalent +to the Oracle7 `connect /' syntax. If values have been set for +OCI_ATTR_USERNAME and OCI_ATTR_PASSWORD, then these are +ignored if OCI_CRED_EXT is used. +Parameters +svchp (IN) - a handle to a service context. There must be a valid server +handle set in svchp. +errhp (IN) - an error handle to the retrieve diagnostic information. +usrhp (IN/OUT) - a handle to an authentication context, which is initialized +by this call. +credt (IN) - specifies the type of credentials to use for authentication. +Valid values for credt are: +OCI_CRED_RDBMS - authenticate using a database username and +password pair as credentials. The attributes OCI_ATTR_USERNAME +and OCI_ATTR_PASSWORD should be set on the authentication +context before this call. +OCI_CRED_EXT - authenticate using external credentials. No username +or password is provided. +mode (IN) - specifies the various modes of operation. Valid modes are: +OCI_DEFAULT - in this mode, the authentication context returned may +only ever be set with the same server context specified in svchp. This +establishes the primary authentication context. +OCI_MIGRATE - in this mode, the new authentication context may be +set in a service handle with a different server handle. This mode +establishes the user authentication context. +OCI_SYSDBA - in this mode, the user is authenticated for SYSDBA +access. +OCI_SYSOPER - in this mode, the user is authenticated for SYSOPER +access. +OCI_SYSASM - in this mode, the user is authenticated for SYSASM +access. Note that only an ASM instance can grant SYSASM access. +OCI_PRELIM_AUTH - this mode may only be used with OCI_SYSDBA, OCI_SYSASM, +or OCI_SYSOPER to authenticate for certain administration tasks. +Related Functions +OCISessionEnd() + + + + + + +OCISessionEnd() +Name +OCI Terminate user Authentication Context +Purpose +Terminates a user authentication context created by OCISessionBegin() +Syntax +sword OCISessionEnd ( OCISvcCtx *svchp, + OCIError *errhp, + OCISession *usrhp, + ub4 mode); + +Comments +The user security context associated with the service context is invalidated +by this call. Storage for the authentication context is not freed. The +transaction specified by the service context is implicitly committed. The +transaction handle, if explicitly allocated, may be freed if not being used. +Resources allocated on the server for this user are freed. +The authentication handle may be reused in a new call to OCISessionBegin(). +Parameters +svchp (IN/OUT) - the service context handle. There must be a valid server +handle and user authentication handle associated with svchp. +errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +usrhp (IN) - de-authenticate this user. If this parameter is passed as NULL, +the user in the service context handle is de-authenticated. +mode (IN) - the only valid mode is OCI_DEFAULT. +Example +In this example, an authentication context is destroyed. +Related Functions +OCISessionBegin() + + + + +OCIStmtExecute() +Name +OCI EXECute +Purpose +This call associates an application request with a server. +Syntax +sword OCIStmtExecute ( OCISvcCtx *svchp, + OCIStmt *stmtp, + OCIError *errhp, + ub4 iters, + ub4 rowoff, + const OCISnapshot *snap_in, + OCISnapshot *snap_out, + ub4 mode ); +Comments +This function is used to execute a prepared SQL statement. +Using an execute call, the application associates a request with a server. On +success, OCI_SUCCESS is returned. +If a SELECT statement is executed, the description of the select list follows +implicitly as a response. This description is buffered on the client side for +describes, fetches and define type conversions. Hence it is optimal to +describe a select list only after an execute. +Also for SELECT statements, some results are available implicitly. Rows will +be received and buffered at the end of the execute. For queries with small row +count, a prefetch causes memory to be released in the server if the end of +fetch is reached, an optimization that may result in memory usage reduction. +Set attribute call has been defined to set the number of rows to be prefetched +per result set. +For SELECT statements, at the end of the execute, the statement handle +implicitly maintains a reference to the service context on which it is +executed. It is the user's responsibility to maintain the integrity of the +service context. If the attributes of a service context is changed for +executing some operations on this service context, the service context must +be restored to have the same attributes, that a statement was executed with, +prior to a fetch on the statement handle. The implicit reference is maintained +until the statement handle is freed or the fetch is cancelled or an end of +fetch condition is reached. +Note: If output variables are defined for a SELECT statement before a +call to OCIStmtExecute(), the number of rows specified by iters will be +fetched directly into the defined output buffers and additional rows +equivalent to the prefetch count will be prefetched. If there are no +additional rows, then the fetch is complete without calling +OCIStmtFetch(). +The execute call will return errors if the statement has bind data types that +are not supported in an Oracle7 server. +Parameters +svchp (IN/OUT) - service context handle. +stmtp (IN/OUT) - an statement handle - defines the statement and the +associated data to be executed at the server. It is invalid to pass in a +statement handle that has bind of data types only supported in release 8.0 +when srvchp points to an Oracle7 server. +errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. If the statement is being +batched and it is successful, then this handle will contain this particular +statement execution specific errors returned from the server when the batch is +flushed. +iters (IN) - the number of times this statement is executed for non-Select +statements. For Select statements, if iters is non-zero, then defines must +have been done for the statement handle. The execution fetches iters rows into +these predefined buffers and prefetches more rows depending upon the prefetch +row count. This function returns an error if iters=0 for non-SELECT +statements. +rowoff (IN) - the index from which the data in an array bind is relevant for +this multiple row execution. +snap_in (IN) - this parameter is optional. if supplied, must point to a +snapshot descriptor of type OCI_DTYPE_SNAP. The contents of this descriptor +must be obtained from the snap_out parameter of a previous call. The +descriptor is ignored if the SQL is not a SELECT. This facility allows +multiple service contexts to ORACLE to see the same consistent snapshot of the +database's committed data. However, uncommitted data in one context is not +visible to another context even using the same snapshot. +snap_out (OUT) - this parameter optional. if supplied, must point to a +descriptor of type OCI_DTYPE_SNAP. This descriptor is filled in with an +opaque representation which is the current ORACLE "system change +number" suitable as a snap_in input to a subsequent call to OCIStmtExecute(). +This descriptor should not be used any longer than necessary in order to avoid +"snapshot too old" errors. +mode (IN) - The modes are: +If OCI_DEFAULT_MODE, the default mode, is selected, the request is +immediately executed. Error handle contains diagnostics on error if any. +OCI_EXACT_FETCH - if the statement is a SQL SELECT, this mode is +only valid if the application has set the prefetch row count prior to this +call. In this mode, the OCI library will get up to the number of rows +specified (i.e., prefetch row count plus iters). If the number of rows +returned by the query is greater than this value, OCI_ERROR will be +returned with ORA-01422 as the implementation specific error in a +diagnostic record. If the number of rows returned by the query is +smaller than the prefetch row count, OCI_SUCCESS_WITH_INFO will +be returned with ORA-01403 as the implementation specific error. The +prefetch buffer size is ignored and the OCI library tries to allocate all the +space required to contain the prefetched rows. The exact fetch semantics +apply to only the top level rows. No more rows can be fetched for this +query at the end of the call. +OCI_KEEP_FETCH_STATE - the result set rows (not yet fetched) of this +statement executed in this transaction will be maintained when the +transaction is detached for migration. By default, a query is cancelled +when a transaction is detached for migration. This mode is the default +mode when connected to a V7 server. +Related Functions +OCIStmtPrepare() + + + + + +OCIStmtFetch() +Name +OCI FetCH +Purpose +Fetches rows from a query. +Syntax +sword OCIStmtFetch ( OCIStmt *stmtp, + OCIError *errhp, + ub4 nrows, + ub2 orientation, + ub4 mode); +Comments +The fetch call is a local call, if prefetched rows suffice. However, this is +transparent to the application. If LOB columns are being read, LOB locators +are fetched for subsequent LOB operations to be performed on these locators. +Prefetching is turned off if LONG columns are involved. +A fetch with nrows set to 0 rows effectively cancels the fetch for this +statement. +Parameters +stmtp (IN) - a statement (application request) handle. +errhp (IN) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +nrows (IN) - number of rows to be fetched from the current position. +orientation (IN) - for release 8.0, the only acceptable value is +OCI_FETCH_NEXT, which is also the default value. +mode (IN) - for release 8.0, beta-1, the following mode is defined. +OCI_DEFAULT - default mode +OCI_EOF_FETCH - indicates that it is the last fetch from the result set. +If nrows is non-zero, setting this mode effectively cancels fetching after +retrieving nrows, otherwise it cancels fetching immediately. +Related Functions +OCIAttrGet() + +OCIStmtFetch2() +Name +OCI FetCH2 +Purpose +Fetches rows from a query. +Syntax +sword OCIStmtFetch2 ( OCIStmt *stmtp, + OCIError *errhp, + ub4 nrows, + ub2 orientation, + ub4 scrollOffset, + ub4 mode); +Comments +The fetch call works similar to the OCIStmtFetch call with the +addition of the fetchOffset parameter. It can be used on any +statement handle, whether it is scrollable or not. For a +non-scrollable statement handle, the only acceptable value +will be OCI_FETCH_NEXT, and the fetchOffset parameter will be +ignored. Applications are encouraged to use this new call. + +A fetchOffset with OCI_FETCH_RELATIVE is equivalent to +OCI_FETCH_CURRENT with a value of 0, is equivalent to +OCI_FETCH_NEXT with a value of 1, and equivalent to +OCI_FETCH_PRIOR with a value of -1. Note that the range of +accessible rows is [1,OCI_ATTR_ROW_COUNT] beyond which an +error could be raised if sufficient rows do not exist in + +The fetch call is a local call, if prefetched rows suffice. However, this is +transparent to the application. If LOB columns are being read, LOB locators +are fetched for subsequent LOB operations to be performed on these locators. +Prefetching is turned off if LONG columns are involved. +A fetch with nrows set to 0 rows effectively cancels the fetch for this +statement. +Parameters +stmtp (IN) - a statement (application request) handle. +errhp (IN) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +nrows (IN) - number of rows to be fetched from the current position. +It defaults to 1 for orientation OCI_FETCH_LAST. +orientation (IN) - The acceptable values are as follows, with +OCI_FETCH_NEXT being the default value. +OCI_FETCH_CURRENT gets the current row, +OCI_FETCH_NEXT gets the next row from the current position, +OCI_FETCH_FIRST gets the first row in the result set, +OCI_FETCH_LAST gets the last row in the result set, +OCI_FETCH_PRIOR gets the previous row from the current row in the result set, +OCI_FETCH_ABSOLUTE will fetch the row number (specified by fetchOffset +parameter) in the result set using absolute positioning, +OCI_FETCH_RELATIVE will fetch the row number (specified by fetchOffset +parameter) in the result set using relative positioning. +scrollOffset(IN) - offset used with the OCI_FETCH_ABSOLUTE and +OCI_FETCH_RELATIVE orientation parameters only. It specify +the new current position for scrollable result set. It is +ignored for non-scrollable result sets. +mode (IN) - for release 8.0, beta-1, the following mode is defined. +OCI_DEFAULT - default mode +OCI_EOF_FETCH - indicates that it is the last fetch from the result set. +If nrows is non-zero, setting this mode effectively cancels fetching after +retrieving nrows, otherwise it cancels fetching immediately. +Related Functions +OCIAttrGet() + + + +OCIStmtGetPieceInfo() +Name +OCI Get Piece Information +Purpose +Returns piece information for a piecewise operation. +Syntax +sword OCIStmtGetPieceInfo( const OCIStmt *stmtp, + OCIError *errhp, + void **hndlpp, + ub4 *typep, + ub1 *in_outp, + ub4 *iterp, + ub4 *idxp, + ub1 *piecep ); + +Comments +When an execute/fetch call returns OCI_NEED_DATA to get/return a +dynamic bind/define value or piece, OCIStmtGetPieceInfo() returns the +relevant information: bind/define handle, iteration or index number and +which piece. +See the section "Runtime Data Allocation and Piecewise Operations" on page +5-16 for more information about using OCIStmtGetPieceInfo(). +Parameters +stmtp (IN) - the statement when executed returned OCI_NEED_DATA. +errhp (OUT) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +hndlpp (OUT) - returns a pointer to the bind or define handle of the bind or +define whose runtime data is required or is being provided. +typep (OUT) - the type of the handle pointed to by hndlpp: OCI_HTYPE_BIND +(for a bind handle) or OCI_HTYPE_DEFINE (for a define handle). +in_outp (OUT) - returns OCI_PARAM_IN if the data is required for an IN bind +value. Returns OCI_PARAM_OUT if the data is available as an OUT bind +variable or a define position value. +iterp (OUT) - returns the row number of a multiple row operation. +idxp (OUT) - the index of an array element of a PL/SQL array bind operation. +piecep (OUT) - returns one of the following defined values - +OCI_ONE_PIECE, OCI_FIRST_PIECE, OCI_NEXT_PIECE and +OCI_LAST_PIECE. The default value is always OCI_ONE_PIECE. +Related Functions +OCIAttrGet(), OCIAttrGet(), OCIStmtExecute(), OCIStmtFetch(), +OCIStmtSetPieceInfo() + + + + +OCIStmtPrepare() +Name +OCI Statement REQuest +Purpose +This call defines the SQL/PLSQL statement to be executed. +Syntax +sword OCIStmtPrepare ( OCIStmt *stmtp, + OCIError *errhp, + const OraText *stmt, + ub4 stmt_len, + ub4 language, + ub4 mode); +Comments +This call is used to prepare a SQL or PL/SQL statement for execution. The +OCIStmtPrepare() call defines an application request. +This is a purely local call. Data values for this statement initialized in +subsequent bind calls will be stored in a bind handle which will hang off this +statement handle. +This call does not create an association between this statement handle and any +particular server. +See the section "Preparing Statements" on page 2-21 for more information +about using this call. +Parameters +stmtp (IN) - a statement handle. +errhp (IN) - an error handle to retrieve diagnostic information. +stmt (IN) - SQL or PL/SQL statement to be executed. Must be a null-terminated +string. The pointer to the OraText of the statement must be available as long +as the statement is executed. +stmt_len (IN) - length of the statement. Must not be zero. +language (IN) - V7, V8, or native syntax. Possible values are: +OCI_V7_SYNTAX - V7 ORACLE parsing syntax +OCI_V8_SYNTAX - V8 ORACLE parsing syntax +OCI_NTV_SYNTAX - syntax depending upon the version of the server. +mode (IN) - the only defined mode is OCI_DEFAULT for default mode. +Example +This example demonstrates the use of OCIStmtPrepare(), as well as the OCI +application initialization calls. +Related Functions +OCIAttrGet(), OCIStmtExecute() + + +OCIStmtPrepare2() +Name +OCI Statement REQuest with (a) early binding to svchp and/or +(b) stmt caching +Purpose +This call defines the SQL/PLSQL statement to be executed. +Syntax +sword OCIStmtPrepare2 ( OCISvcCtx *svchp, + OCIStmt **stmtp, + OCIError *errhp, + const OraText *stmt, + ub4 stmt_len, + const OraText *key, + ub4 key_len, + ub4 language, + ub4 mode); +Comments +This call is used to prepare a SQL or PL/SQL statement for execution. The +OCIStmtPrepare() call defines an application request. +This is a purely local call. Data values for this statement initialized in +subsequent bind calls will be stored in a bind handle which will hang off this +statement handle. +This call creates an association between the statement handle and a service +context. It differs from OCIStmtPrepare in that respect.It also supports +stmt caching. The stmt will automatically be cached if the authp of the stmt +has enabled stmt caching. +Parameters +svchp (IN) - the service context handle that contains the session that + this stmt handle belongs to. +stmtp (OUT) - an unallocated stmt handle must be pased in. An allocated + and prepared statement handle will be returned. +errhp (IN) - an error handle to retrieve diagnostic information. +stmt (IN) - SQL or PL/SQL statement to be executed. Must be a null- + terminated string. The pointer to the OraText of the statement + must be available as long as the statement is executed. +stmt_len (IN) - length of the statement. Must not be zero. +key (IN) - This is only Valid for OCI Stmt Caching. It indicates the + key to search with. It thus optimizes the search in the cache. +key_len (IN) - the length of the key. This, too, is onlly valid for stmt + caching. +language (IN) - V7, V8, or native syntax. Possible values are: +OCI_V7_SYNTAX - V7 ORACLE parsing syntax +OCI_V8_SYNTAX - V8 ORACLE parsing syntax +OCI_NTV_SYNTAX - syntax depending upon the version of the server. +mode (IN) - the defined modes are OCI_DEFAULT and OCI_PREP2_CACHE_SEARCHONLY. +Example +Related Functions +OCIStmtExecute(), OCIStmtRelease() + + +OCIStmtRelease() +Name +OCI Statement Release. This call is used to relesae the stmt that +was retreived using OCIStmtPrepare2(). If the stmt is release +using this call, OCIHandleFree() must not be called on the stmt +handle. +Purpose +This call releases the statement obtained by OCIStmtPrepare2 +Syntax +sword OCIStmtRelease ( OCIStmt *stmtp, + OCIError *errhp, + cONST OraText *key, + ub4 key_len, + ub4 mode); +Comments +This call is used to release a handle obtained via OCIStmtPrepare2(). +It also frees the memory associated with the handle. +This is a purely local call. +Parameters +stmtp (IN/OUT) - The statement handle to be released/freed. +errhp (IN) - an error handle to retrieve diagnostic information. +key (IN) - This is only Valid for OCI Stmt Caching. It indicates the + key to tag the stmt with. +key_len (IN) - the length of the key. This, too, is only valid for stmt + caching. +mode (IN) - the defined modes are OCI_DEFAULT for default mode and + OCI_STRLS_CACHE_DELETE (only used for Stmt Caching). +Example +Related Functions +OCIStmtExecute(), OCIStmtPrepare2() + + +OCIStmtSetPieceInfo() +Name +OCI Set Piece Information +Purpose +Sets piece information for a piecewise operation. +Syntax +sword OCIStmtSetPieceInfo ( void *hndlp, + ub4 type, + OCIError *errhp, + const void *bufp, + ub4 *alenp, + ub1 piece, + const void *indp, + ub2 *rcodep ); +Comments +When an execute call returns OCI_NEED_DATA to get a dynamic IN/OUT +bind value or piece, OCIStmtSetPieceInfo() sets the piece information: the +buffer, the length, the indicator and which piece is currently being processed. +For more information about using OCIStmtSetPieceInfo() see the section +"Runtime Data Allocation and Piecewise Operations" on page 5-16. +Parameters +hndlp (IN/OUT) - the bind/define handle. +type (IN) - type of the handle. +errhp (OUT) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +bufp (IN/OUT) - bufp is a pointer to a storage containing the data value or +the piece when it is an IN bind variable, otherwise bufp is a pointer to +storage for getting a piece or a value for OUT binds and define variables. For +named data types or REFs, a pointer to the object or REF is returned. +alenp (IN/OUT) - the length of the piece or the value. +piece (IN) - the piece parameter. The following are valid values: +OCI_ONE_PIECE, OCI_FIRST_PIECE, OCI_NEXT_PIECE, or +OCI_LAST_PIECE. +The default value is OCI_ONE_PIECE. This parameter is used for IN bind +variables only. +indp (IN/OUT) - indicator. A pointer to a sb2 value or pointer to an indicator +structure for named data types (SQLT_NTY) and REFs (SQLT_REF), i.e., *indp +is either an sb2 or a void * depending upon the data type. +rcodep (IN/OUT) - return code. +Related Functions +OCIAttrGet(), OCIAttrGet(), OCIStmtExecute(), OCIStmtFetch(), +OCIStmtGetPieceInfo() + + +OCIFormatInit +Name +OCIFormat Package Initialize +Purpose +Initializes the OCIFormat package. +Syntax +sword OCIFormatInit(void *hndl, OCIError *err); +Comments +This routine must be called before calling any other OCIFormat routine. +Returns OCI_SUCCESS, OCI_INVALID_HANDLE, or OCI_ERROR +Parameters +hndl (IN/OUT) - OCI environment or session handle +err (IN/OUT) - OCI error handle +Related Functions +OCIFormatTerm() + + +OCIFormatString +Name +OCIFormat Package Format String +Purpose +Writes a text string into the supplied text buffer using the argument +list submitted to it and in accordance with the format string given. +Syntax +sword OCIFormatString(void *hndl, OCIError *err, OraText *buffer, + sbig_ora bufferLength, sbig_ora *returnLength, + const OraText *formatString, ...); +Comments +The first call to this routine must be preceded by a call to the +OCIFormatInit routine that initializes the OCIFormat package +for use. When this routine is no longer needed then terminate +the OCIFormat package by a call to the OCIFormatTerm routine. +Returns OCI_SUCCESS, OCI_INVALID_HANDLE, or OCI_ERROR +Parameters +hndl (IN/OUT) - OCI environment or session handle +err (IN/OUT) - OCI error handle +buffer (OUT) - text buffer for the string +bufferLength (IN) - length of the text buffer +returnLength (OUT) - length of the formatted string +formatString (IN) - format specification string +... (IN) - variable argument list +Related Functions + + +OCIFormatTerm +Name +OCIFormat Package Terminate +Purpose +Terminates the OCIFormat package. +Syntax +sword OCIFormatTerm(void *hndl, OCIError *err); +Comments +It must be called after the OCIFormat package is no longer being used. +Returns OCI_SUCCESS, OCI_INVALID_HANDLE, or OCI_ERROR +Parameters +hndl (IN/OUT) - OCI environment or session handle +err (IN/OUT) - OCI error handle +Related Functions +OCIFormatInit() + + +OCIFormatTUb1 +Name +OCIFormat Package ub1 Type +Purpose +Return the type value for the ub1 type. +Syntax +sword OCIFormatTUb1(void); +Comments +None +Parameters +None +Related Functions +None + + +OCIFormatTUb2 +Name +OCIFormat Package ub2 Type +Purpose +Return the type value for the ub2 type. +Syntax +sword OCIFormatTUb2(void); +Comments +None +Parameters +None +Related Functions +None + + +OCIFormatTUb4 +Name +OCIFormat Package ub4 Type +Purpose +Return the type value for the ub4 type. +Syntax +sword OCIFormatTUb4(void); +Comments +None +Parameters +None +Related Functions +None + + +OCIFormatTUword +Name +OCIFormat Package uword Type +Purpose +Return the type value for the uword type. +Syntax +sword OCIFormatTUword(void); +Comments +None +Parameters +None +Related Functions +None + + +OCIFormatTUbig_ora +Name +OCIFormat Package ubig_ora Type +Purpose +Return the type value for the ubig_ora type. +Syntax +sword OCIFormatTUbig_ora(void); +Comments +None +Parameters +None +Related Functions +None + + +OCIFormatTSb1 +Name +OCIFormat Package sb1 Type +Purpose +Return the type value for the sb1 type. +Syntax +sword OCIFormatTSb1(void); +Comments +None +Parameters +None +Related Functions +None + + +OCIFormatTSb2 +Name +OCIFormat Package sb2 Type +Purpose +Return the type value for the sb2 type. +Syntax +sword OCIFormatTSb2(void); +Comments +None +Parameters +None +Related Functions +None + + +OCIFormatTSb4 +Name +OCIFormat Package sb4 Type +Purpose +Return the type value for the sb4 type. +Syntax +sword OCIFormatTSb4(void); +Comments +None +Parameters +None +Related Functions +None + + +OCIFormatTSword +Name +OCIFormat Package sword Type +Purpose +Return the type value for the sword type. +Syntax +sword OCIFormatTSword(void); +Comments +None +Parameters +None +Related Functions +None + + +OCIFormatTSbig_ora +Name +OCIFormat Package sbig_ora Type +Purpose +Return the type value for the sbig_ora type. +Syntax +sword OCIFormatTSbig_ora(void); +Comments +None +Parameters +None +Related Functions +None + + +OCIFormatTEb1 +Name +OCIFormat Package eb1 Type +Purpose +Return the type value for the eb1 type. +Syntax +sword OCIFormatTEb1(void); +Comments +None +Parameters +None +Related Functions +None + + +OCIFormatTEb2 +Name +OCIFormat Package eb2 Type +Purpose +Return the type value for the eb2 type. +Syntax +sword OCIFormatTEb2(void); +Comments +None +Parameters +None +Related Functions +None + + +OCIFormatTEb4 +Name +OCIFormat Package eb4 Type +Purpose +Return the type value for the eb4 type. +Syntax +sword OCIFormatTEb4(void); +Comments +None +Parameters +None +Related Functions +None + + +OCIFormatTEword +Name +OCIFormat Package eword Type +Purpose +Return the type value for the eword type. +Syntax +sword OCIFormatTEword(void); +Comments +None +Parameters +None +Related Functions +None + + +OCIFormatTChar +Name +OCIFormat Package text Type +Purpose +Return the type value for the text type. +Syntax +sword OCIFormatTChar(void); +Comments +None +Parameters +None +Related Functions +None + + +OCIFormatTText +Name +OCIFormat Package *text Type +Purpose +Return the type value for the *text type. +Syntax +sword OCIFormatTText(void); +Comments +None +Parameters +None +Related Functions +None + + +OCIFormatTDouble +Name +OCIFormat Package double Type +Purpose +Return the type value for the double type. +Syntax +sword OCIFormatTDouble(void); +Comments +None +Parameters +None +Related Functions +None + + +OCIFormatDvoid +Name +OCIFormat Package void Type +Purpose +Return the type value for the void type. +Syntax +sword OCIFormatTDvoid(void); +Comments +None +Parameters +None +Related Functions +None + + +OCIFormatTEnd +Name +OCIFormat Package end Type +Purpose +Return the list terminator's "type". +Syntax +sword OCIFormatTEnd(void); +Comments +None +Parameters +None +Related Functions +None + + +OCISvcCtxToLda() +Name +OCI toggle SerVice context handle to Version 7 Lda_Def +Purpose +Toggles between a V8 service context handle and a V7 Lda_Def. +Syntax +sword OCISvcCtxToLda ( OCISvcCtx *srvhp, + OCIError *errhp, + Lda_Def *ldap ); +Comments +Toggles between an Oracle8 service context handle and an Oracle7 Lda_Def. +This function can only be called after a service context has been properly +initialized. +Once the service context has been translated to an Lda_Def, it can be used in +release 7.x OCI calls (e.g., obindps(), ofen()). +Note: If there are multiple service contexts which share the same server +handle, only one can be in V7 mode at any time. +The action of this call can be reversed by passing the resulting Lda_Def to +the OCILdaToSvcCtx() function. +Parameters +svchp (IN/OUT) - the service context handle. +errhp (IN/OUT) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +ldap (IN/OUT) - a Logon Data Area for V7-style OCI calls which is initialized +by this call. +Related Functions +OCILdaToSvcCtx() + + + + +OCITransCommit() +Name +OCI TX (transaction) CoMmit +Purpose +Commits the transaction associated with a specified service context. +Syntax +sword OCITransCommit ( OCISvcCtx *srvcp, + OCIError *errhp, + ub4 flags ); +Comments +The transaction currently associated with the service context is committed. If +it is a distributed transaction that the server cannot commit, this call +additionally retrieves the state of the transaction from the database to be +returned to the user in the error handle. +If the application has defined multiple transactions, this function operates +on the transaction currently associated with the service context. If the +application is working with only the implicit local transaction created when +database changes are made, that implicit transaction is committed. +If the application is running in the object mode, then the modified or updated +objects in the object cache for this transaction are also committed. +The flags parameter is used for one-phase commit optimization in distributed +transactions. If the transaction is non-distributed, the flags parameter is +ignored, and OCI_DEFAULT can be passed as its value. OCI applications +managing global transactions should pass a value of +OCI_TRANS_TWOPHASE to the flags parameter for a two-phase commit. The +default is one-phase commit. +Under normal circumstances, OCITransCommit() returns with a status +indicating that the transaction has either been committed or rolled back. With +distributed transactions, it is possible that the transaction is now in-doubt +(i.e., neither committed nor aborted). In this case, OCITransCommit() +attempts to retrieve the status of the transaction from the server. +The status is returned. +Parameters +srvcp (IN) - the service context handle. +errhp (IN) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +flags -see the "Comments" section above. +Related Functions +OCITransRollback() + + + + +OCITransDetach() +Name +OCI TX (transaction) DeTach +Purpose +Detaches a transaction. +Syntax +sword OCITransDetach ( OCISvcCtx *srvcp, + OCIError *errhp, + ub4 flags); +Comments +Detaches a global transaction from the service context handle. The transaction +currently attached to the service context handle becomes inactive at the end +of this call. The transaction may be resumed later by calling OCITransStart(), +specifying a flags value of OCI_TRANS_RESUME. +When a transaction is detached, the value which was specified in the timeout +parameter of OCITransStart() when the transaction was started is used to +determine the amount of time the branch can remain inactive before being +deleted by the server's PMON process. +Note: The transaction can be resumed by a different process than the one +that detached it, provided that the transaction has the same +authorization. +Parameters +srvcp (IN) - the service context handle. +errhp (IN) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +flags (IN) - you must pass a value of OCI_DEFAULT for this parameter. +Related Functions +OCITransStart() + + + +OCITransForget() +Name +OCI TX (transaction) ForGeT +Purpose +Causes the server to forget a heuristically completed global transaction. +Syntax +sword OCITransForget ( OCISvcCtx *svchp, + OCIError *errhp, + ub4 flags); + +Comments + +Forgets a heuristically completed global transaction. The server deletes the +status of the transaction from the system's pending transaction table. +The XID of the transaction to be forgotten is set as an attribute of the +transaction handle (OCI_ATTR_XID). +Parameters +srvcp (IN) - the service context handle - the transaction is rolled back. +errhp (IN) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +flags (IN) - you must pass OCI_DEFAULT for this parameter. +Related Functions +OCITransCommit(), OCITransRollback() + + +OCITransMultiPrepare() +Name +OCI Trans(action) Multi-Branch Prepare +Purpose +Prepares a transaction with multiple branches in a single call. +Syntax +sword OCITransMultiPrepare ( OCISvcCtx *svchp, + ub4 numBranches, + OCITrans **txns, + OCIError **errhp); + +Comments + +Prepares the specified global transaction for commit. +This call is valid only for distributed transactions. +This call is an advanced performance feature intended for use only in +situations where the caller is responsible for preparing all the branches +in a transaction. +Parameters +srvcp (IN) - the service context handle. +numBranches (IN) - This is the number of branches expected. It is also the +array size for the next two parameters. +txns (IN) - This is the array of transaction handles for the branches to +prepare. They should all have the OCI_ATTR_XID set. The global transaction +ID should be the same. +errhp (IN) - This is the array of error handles. If OCI_SUCCESS is not +returned, then these will indicate which branches received which errors. +Related Functions +OCITransPrepare() + + +OCITransPrepare() +Name +OCI TX (transaction) PREpare +Purpose +Prepares a transaction for commit. +Syntax +sword OCITransPrepare ( OCISvcCtx *svchp, + OCIError *errhp, + ub4 flags); + +Comments + +Prepares the specified global transaction for commit. +This call is valid only for distributed transactions. +The call returns OCI_SUCCESS_WITH_INFO if the transaction has not made +any changes. The error handle will indicate that the transaction is read-only. +The flag parameter is not currently used. +Parameters +srvcp (IN) - the service context handle. +errhp (IN) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +flags (IN) - you must pass OCI_DEFAULT for this parameter. +Related Functions +OCITransCommit(), OCITransForget() + + + + +OCITransRollback() +Name +OCI TX (transaction) RoLlback +Purpose +Rolls back the current transaction. +Syntax +sword OCITransRollback ( void *svchp, + OCIError *errhp, + ub4 flags ); +Comments +The current transaction- defined as the set of statements executed since the +last OCITransCommit() or since OCISessionBegin()-is rolled back. +If the application is running under object mode then the modified or updated +objects in the object cache for this transaction are also rolled back. +An error is returned if an attempt is made to roll back a global transaction +that is not currently active. +Parameters +svchp (IN) - a service context handle. The transaction currently set in the +service context handle is rolled back. +errhp -(IN) - an error handle which can be passed to OCIErrorGet() for +diagnostic information in the event of an error. +flags - you must pass a value of OCI_DEFAULT for this parameter. +Related Functions +OCITransCommit() + + + + +OCITransStart() +Name +OCI TX (transaction) STart +Purpose +Sets the beginning of a transaction. +Syntax +sword OCITransStart ( OCISvcCtx *svchp, + OCIError *errhp, + uword timeout, + ub4 flags); + +Comments +This function sets the beginning of a global or serializable transaction. The +transaction context currently associated with the service context handle is +initialized at the end of the call if the flags parameter specifies that a new +transaction should be started. +The XID of the transaction is set as an attribute of the transaction handle +(OCI_ATTR_XID) +Parameters +svchp (IN/OUT) - the service context handle. The transaction context in the +service context handle is initialized at the end of the call if the flag +specified a new transaction to be started. +errhp (IN/OUT) - The OCI error handle. If there is an error, it is recorded in +err and this function returns OCI_ERROR. Diagnostic information can be +obtained by calling OCIErrorGet(). +timeout (IN) - the time, in seconds, to wait for a transaction to become +available for resumption when OCI_TRANS_RESUME is specified. When +OCI_TRANS_NEW is specified, this value is stored and may be used later by +OCITransDetach(). +flags (IN) - specifies whether a new transaction is being started or an +existing transaction is being resumed. Also specifies serializiability or +read-only status. More than a single value can be specified. By default, +a read/write transaction is started. The flag values are: +OCI_TRANS_NEW - starts a new transaction branch. By default starts a +tightly coupled and migratable branch. +OCI_TRANS_TIGHT - explicitly specifies a tightly coupled branch +OCI_TRANS_LOOSE - specifies a loosely coupled branch +OCI_TRANS_RESUME - resumes an existing transaction branch. +OCI_TRANS_READONLY - start a readonly transaction +OCI_TRANS_SERIALIZABLE - start a serializable transaction +Related Functions +OCITransDetach() + + + + + +******************************************************************************/ +/*-----------------------Dynamic Callback Function Pointers------------------*/ + + +typedef sb4 (*OCICallbackInBind)(void *ictxp, OCIBind *bindp, ub4 iter, + ub4 index, void **bufpp, ub4 *alenp, + ub1 *piecep, void **indp); + +typedef sb4 (*OCICallbackOutBind)(void *octxp, OCIBind *bindp, ub4 iter, + ub4 index, void **bufpp, ub4 **alenp, + ub1 *piecep, void **indp, + ub2 **rcodep); + +typedef sb4 (*OCICallbackDefine)(void *octxp, OCIDefine *defnp, ub4 iter, + void **bufpp, ub4 **alenp, ub1 *piecep, + void **indp, ub2 **rcodep); + +typedef sword (*OCIUserCallback)(void *ctxp, void *hndlp, ub4 type, + ub4 fcode, ub4 when, sword returnCode, + sb4 *errnop, va_list arglist); + +typedef sword (*OCIEnvCallbackType)(OCIEnv *env, ub4 mode, + size_t xtramem_sz, void *usrmemp, + OCIUcb *ucbDesc); + +typedef sb4 (*OCICallbackLobRead)(void *ctxp, const void *bufp, + ub4 len, ub1 piece); + +typedef sb4 (*OCICallbackLobWrite)(void *ctxp, void *bufp, + ub4 *lenp, ub1 *piece); + +#ifdef ORAXB8_DEFINED + +typedef sb4 (*OCICallbackLobRead2)(void *ctxp, const void *bufp, oraub8 len, + ub1 piece, void **changed_bufpp, + oraub8 *changed_lenp); + +typedef sb4 (*OCICallbackLobWrite2)(void *ctxp, void *bufp, oraub8 *lenp, + ub1 *piece, void **changed_bufpp, + oraub8 *changed_lenp); + +typedef sb4 (*OCICallbackLobArrayRead)(void *ctxp, ub4 array_iter, + const void *bufp, oraub8 len, + ub1 piece, void **changed_bufpp, + oraub8 *changed_lenp); + +typedef sb4 (*OCICallbackLobArrayWrite)(void *ctxp, ub4 array_iter, + void *bufp, oraub8 *lenp, + ub1 *piece, void **changed_bufpp, + oraub8 *changed_lenp); +#endif + +typedef sb4 (*OCICallbackLobGetDeduplicateRegions)(void *ctxp, + OCILobRegion *regions, + ub4 count, ub1 piece, + OCILobRegion **changed_reg, + ub4 *changed_count); + +typedef sb4 (*OCICallbackAQEnq)(void *ctxp, void **payload, + void **payload_ind); + +typedef sb4 (*OCICallbackAQEnqStreaming)(void *ctxp, void **payload, + void **payload_ind, + OCIAQMsgProperties **msgprop, + OCIType **tdo); + +typedef sb4 (*OCICallbackAQDeq)(void *ctxp, void **payload, + void **payload_ind); + +/*--------------------------Failover Callback Structure ---------------------*/ +typedef sb4 (*OCICallbackFailover)(void *svcctx, void *envctx, + void *fo_ctx, ub4 fo_type, + ub4 fo_event); + +typedef struct +{ + OCICallbackFailover callback_function; + void *fo_ctx; +} +OCIFocbkStruct; + +/*---------------------Statement Cache callback function ------------------*/ + +typedef sword (*OCICallbackStmtCache)(void *ctx, OCIStmt *stmt, ub4 mode); + +/*--------------------------HA Callback Structure ---------------------*/ +typedef void (*OCIEventCallback)(void *evtctx, OCIEvent *eventhp); + + +/***************************************************************************** + ACTUAL PROTOTYPE DECLARATIONS +******************************************************************************/ + +sword OCIInitialize (ub4 mode, void *ctxp, + void *(*malocfp)(void *ctxp, size_t size), + void *(*ralocfp)(void *ctxp, void *memptr, size_t newsize), + void (*mfreefp)(void *ctxp, void *memptr) ); + +sword OCITerminate( ub4 mode); + +sword OCIEnvCreate (OCIEnv **envp, ub4 mode, void *ctxp, + void *(*malocfp)(void *ctxp, size_t size), + void *(*ralocfp)(void *ctxp, void *memptr, size_t newsize), + void (*mfreefp)(void *ctxp, void *memptr), + size_t xtramem_sz, void **usrmempp); + +sword OCIEnvNlsCreate (OCIEnv **envp, ub4 mode, void *ctxp, + void *(*malocfp)(void *ctxp, size_t size), + void *(*ralocfp)(void *ctxp, void *memptr, size_t newsize), + void (*mfreefp)(void *ctxp, void *memptr), + size_t xtramem_sz, void **usrmempp, + ub2 charset, ub2 ncharset); + +sword OCIFEnvCreate (OCIEnv **envp, ub4 mode, void *ctxp, + void *(*malocfp)(void *ctxp, size_t size), + void *(*ralocfp)(void *ctxp, void *memptr, size_t newsize), + void (*mfreefp)(void *ctxp, void *memptr), + size_t xtramem_sz, void **usrmempp, void *fupg); + +sword OCIHandleAlloc(const void *parenth, void **hndlpp, const ub4 type, + const size_t xtramem_sz, void **usrmempp); + +sword OCIHandleFree(void *hndlp, const ub4 type); + + +sword OCIDescriptorAlloc(const void *parenth, void **descpp, + const ub4 type, const size_t xtramem_sz, + void **usrmempp); + +sword OCIArrayDescriptorAlloc(const void *parenth, void **descpp, + const ub4 type, ub4 array_size, + const size_t xtramem_sz, void **usrmempp); + +sword OCIDescriptorFree(void *descp, const ub4 type); + +sword OCIArrayDescriptorFree(void **descp, const ub4 type); + +sword OCIEnvInit (OCIEnv **envp, ub4 mode, + size_t xtramem_sz, void **usrmempp); + +sword OCIServerAttach (OCIServer *srvhp, OCIError *errhp, + const OraText *dblink, sb4 dblink_len, ub4 mode); + +sword OCIServerDetach (OCIServer *srvhp, OCIError *errhp, ub4 mode); + +sword OCISessionBegin (OCISvcCtx *svchp, OCIError *errhp, OCISession *usrhp, + ub4 credt, ub4 mode); + +sword OCISessionEnd (OCISvcCtx *svchp, OCIError *errhp, OCISession *usrhp, + ub4 mode); + +sword OCILogon (OCIEnv *envhp, OCIError *errhp, OCISvcCtx **svchp, + const OraText *username, ub4 uname_len, + const OraText *password, ub4 passwd_len, + const OraText *dbname, ub4 dbname_len); + +sword OCILogon2 (OCIEnv *envhp, OCIError *errhp, OCISvcCtx **svchp, + const OraText *username, ub4 uname_len, + const OraText *password, ub4 passwd_len, + const OraText *dbname, ub4 dbname_len, + ub4 mode); + +sword OCILogoff (OCISvcCtx *svchp, OCIError *errhp); + + +sword OCIPasswordChange (OCISvcCtx *svchp, OCIError *errhp, + const OraText *user_name, ub4 usernm_len, + const OraText *opasswd, ub4 opasswd_len, + const OraText *npasswd, ub4 npasswd_len, + ub4 mode); + +sword OCIStmtPrepare (OCIStmt *stmtp, OCIError *errhp, const OraText *stmt, + ub4 stmt_len, ub4 language, ub4 mode); + +sword OCIStmtPrepare2 ( OCISvcCtx *svchp, OCIStmt **stmtp, OCIError *errhp, + const OraText *stmt, ub4 stmt_len, const OraText *key, + ub4 key_len, ub4 language, ub4 mode); + +sword OCIStmtRelease ( OCIStmt *stmtp, OCIError *errhp, const OraText *key, + ub4 key_len, ub4 mode); + +sword OCIBindByPos (OCIStmt *stmtp, OCIBind **bindp, OCIError *errhp, + ub4 position, void *valuep, sb4 value_sz, + ub2 dty, void *indp, ub2 *alenp, ub2 *rcodep, + ub4 maxarr_len, ub4 *curelep, ub4 mode); + +sword OCIBindByName (OCIStmt *stmtp, OCIBind **bindp, OCIError *errhp, + const OraText *placeholder, sb4 placeh_len, + void *valuep, sb4 value_sz, ub2 dty, + void *indp, ub2 *alenp, ub2 *rcodep, + ub4 maxarr_len, ub4 *curelep, ub4 mode); + +sword OCIBindObject (OCIBind *bindp, OCIError *errhp, const OCIType *type, + void **pgvpp, ub4 *pvszsp, void **indpp, + ub4 *indszp); + +sword OCIBindDynamic (OCIBind *bindp, OCIError *errhp, void *ictxp, + OCICallbackInBind icbfp, void *octxp, + OCICallbackOutBind ocbfp); + +sword OCIBindArrayOfStruct (OCIBind *bindp, OCIError *errhp, + ub4 pvskip, ub4 indskip, + ub4 alskip, ub4 rcskip); + +sword OCIStmtGetPieceInfo (OCIStmt *stmtp, OCIError *errhp, + void **hndlpp, ub4 *typep, + ub1 *in_outp, ub4 *iterp, ub4 *idxp, + ub1 *piecep); + +sword OCIStmtSetPieceInfo (void *hndlp, ub4 type, OCIError *errhp, + const void *bufp, ub4 *alenp, ub1 piece, + const void *indp, ub2 *rcodep); + +sword OCIStmtExecute (OCISvcCtx *svchp, OCIStmt *stmtp, OCIError *errhp, + ub4 iters, ub4 rowoff, const OCISnapshot *snap_in, + OCISnapshot *snap_out, ub4 mode); + +sword OCIDefineByPos (OCIStmt *stmtp, OCIDefine **defnp, OCIError *errhp, + ub4 position, void *valuep, sb4 value_sz, ub2 dty, + void *indp, ub2 *rlenp, ub2 *rcodep, ub4 mode); + +sword OCIDefineObject (OCIDefine *defnp, OCIError *errhp, + const OCIType *type, void **pgvpp, + ub4 *pvszsp, void **indpp, ub4 *indszp); + +sword OCIDefineDynamic (OCIDefine *defnp, OCIError *errhp, void *octxp, + OCICallbackDefine ocbfp); + +sword OCIRowidToChar (OCIRowid *rowidDesc, OraText *outbfp, ub2 *outbflp, + OCIError *errhp); + +sword OCIDefineArrayOfStruct (OCIDefine *defnp, OCIError *errhp, ub4 pvskip, + ub4 indskip, ub4 rlskip, ub4 rcskip); + +sword OCIStmtFetch (OCIStmt *stmtp, OCIError *errhp, ub4 nrows, + ub2 orientation, ub4 mode); + +sword OCIStmtFetch2 (OCIStmt *stmtp, OCIError *errhp, ub4 nrows, + ub2 orientation, sb4 scrollOffset, ub4 mode); + +sword OCIStmtGetBindInfo (OCIStmt *stmtp, OCIError *errhp, ub4 size, + ub4 startloc, + sb4 *found, OraText *bvnp[], ub1 bvnl[], + OraText *invp[], ub1 inpl[], ub1 dupl[], + OCIBind **hndl); + +sword OCIDescribeAny (OCISvcCtx *svchp, OCIError *errhp, + void *objptr, + ub4 objnm_len, ub1 objptr_typ, ub1 info_level, + ub1 objtyp, OCIDescribe *dschp); + +sword OCIParamGet (const void *hndlp, ub4 htype, OCIError *errhp, + void **parmdpp, ub4 pos); + +sword OCIParamSet(void *hdlp, ub4 htyp, OCIError *errhp, const void *dscp, + ub4 dtyp, ub4 pos); + +sword OCITransStart (OCISvcCtx *svchp, OCIError *errhp, + uword timeout, ub4 flags ); + +sword OCITransDetach (OCISvcCtx *svchp, OCIError *errhp, ub4 flags ); + +sword OCITransCommit (OCISvcCtx *svchp, OCIError *errhp, ub4 flags); + +sword OCITransRollback (OCISvcCtx *svchp, OCIError *errhp, ub4 flags); + +sword OCITransPrepare (OCISvcCtx *svchp, OCIError *errhp, ub4 flags); + +sword OCITransMultiPrepare (OCISvcCtx *svchp, ub4 numBranches, + OCITrans **txns, OCIError **errhp); + +sword OCITransForget (OCISvcCtx *svchp, OCIError *errhp, ub4 flags); + +sword OCIErrorGet (void *hndlp, ub4 recordno, OraText *sqlstate, + sb4 *errcodep, OraText *bufp, ub4 bufsiz, ub4 type); + +sword OCILobAppend (OCISvcCtx *svchp, OCIError *errhp, + OCILobLocator *dst_locp, + OCILobLocator *src_locp); + +sword OCILobAssign (OCIEnv *envhp, OCIError *errhp, + const OCILobLocator *src_locp, + OCILobLocator **dst_locpp); + +sword OCILobCharSetForm (OCIEnv *envhp, OCIError *errhp, + const OCILobLocator *locp, ub1 *csfrm); + +sword OCILobCharSetId (OCIEnv *envhp, OCIError *errhp, + const OCILobLocator *locp, ub2 *csid); + +sword OCILobCopy (OCISvcCtx *svchp, OCIError *errhp, OCILobLocator *dst_locp, + OCILobLocator *src_locp, ub4 amount, ub4 dst_offset, + ub4 src_offset); + +sword OCILobCreateTemporary(OCISvcCtx *svchp, + OCIError *errhp, + OCILobLocator *locp, + ub2 csid, + ub1 csfrm, + ub1 lobtype, + boolean cache, + OCIDuration duration); + + +sword OCILobClose( OCISvcCtx *svchp, + OCIError *errhp, + OCILobLocator *locp ); + + +sword OCILobDisableBuffering (OCISvcCtx *svchp, + OCIError *errhp, + OCILobLocator *locp); + +sword OCILobEnableBuffering (OCISvcCtx *svchp, + OCIError *errhp, + OCILobLocator *locp); + +sword OCILobErase (OCISvcCtx *svchp, OCIError *errhp, OCILobLocator *locp, + ub4 *amount, ub4 offset); + +sword OCILobFileClose (OCISvcCtx *svchp, OCIError *errhp, + OCILobLocator *filep); + +sword OCILobFileCloseAll (OCISvcCtx *svchp, OCIError *errhp); + +sword OCILobFileExists (OCISvcCtx *svchp, OCIError *errhp, + OCILobLocator *filep, + boolean *flag); + +sword OCILobFileGetName (OCIEnv *envhp, OCIError *errhp, + const OCILobLocator *filep, + OraText *dir_alias, ub2 *d_length, + OraText *filename, ub2 *f_length); + +sword OCILobFileIsOpen (OCISvcCtx *svchp, OCIError *errhp, + OCILobLocator *filep, + boolean *flag); + +sword OCILobFileOpen (OCISvcCtx *svchp, OCIError *errhp, + OCILobLocator *filep, + ub1 mode); + +sword OCILobFileSetName (OCIEnv *envhp, OCIError *errhp, + OCILobLocator **filepp, + const OraText *dir_alias, ub2 d_length, + const OraText *filename, ub2 f_length); + +sword OCILobFlushBuffer (OCISvcCtx *svchp, + OCIError *errhp, + OCILobLocator *locp, + ub4 flag); + +sword OCILobFreeTemporary(OCISvcCtx *svchp, + OCIError *errhp, + OCILobLocator *locp); + +sword OCILobGetChunkSize(OCISvcCtx *svchp, + OCIError *errhp, + OCILobLocator *locp, + ub4 *chunksizep); + +sword OCILobGetLength (OCISvcCtx *svchp, OCIError *errhp, + OCILobLocator *locp, + ub4 *lenp); + +sword OCILobIsEqual (OCIEnv *envhp, const OCILobLocator *x, + const OCILobLocator *y, + boolean *is_equal); + +sword OCILobIsOpen( OCISvcCtx *svchp, + OCIError *errhp, + OCILobLocator *locp, + boolean *flag); + +sword OCILobIsTemporary(OCIEnv *envp, + OCIError *errhp, + OCILobLocator *locp, + boolean *is_temporary); + +sword OCILobLoadFromFile (OCISvcCtx *svchp, OCIError *errhp, + OCILobLocator *dst_locp, + OCILobLocator *src_filep, + ub4 amount, ub4 dst_offset, + ub4 src_offset); + +sword OCILobLocatorAssign (OCISvcCtx *svchp, OCIError *errhp, + const OCILobLocator *src_locp, + OCILobLocator **dst_locpp); + + +sword OCILobLocatorIsInit (OCIEnv *envhp, OCIError *errhp, + const OCILobLocator *locp, + boolean *is_initialized); + +sword OCILobOpen( OCISvcCtx *svchp, + OCIError *errhp, + OCILobLocator *locp, + ub1 mode ); + +sword OCILobRead (OCISvcCtx *svchp, OCIError *errhp, OCILobLocator *locp, + ub4 *amtp, ub4 offset, void *bufp, ub4 bufl, void *ctxp, + OCICallbackLobRead cbfp, ub2 csid, ub1 csfrm); + +sword OCILobTrim (OCISvcCtx *svchp, OCIError *errhp, OCILobLocator *locp, + ub4 newlen); + +sword OCILobWrite (OCISvcCtx *svchp, OCIError *errhp, OCILobLocator *locp, + ub4 *amtp, ub4 offset, void *bufp, ub4 buflen, + ub1 piece, void *ctxp, OCICallbackLobWrite cbfp, + ub2 csid, ub1 csfrm); + +sword OCILobGetDeduplicateRegions(OCISvcCtx *svchp, OCIError *errhp, + OCILobLocator *locp, + OCILobRegion *regp, ub4 *count, ub1 piece, + void *ctxp, + OCICallbackLobGetDeduplicateRegions cbfp); + +sword OCILobWriteAppend(OCISvcCtx *svchp, OCIError *errhp, OCILobLocator *lobp, + ub4 *amtp, void *bufp, ub4 bufl, ub1 piece, + void *ctxp, OCICallbackLobWrite cbfp, ub2 csid, + ub1 csfrm); + +sword OCIBreak (void *hndlp, OCIError *errhp); + +sword OCIReset (void *hndlp, OCIError *errhp); + +sword OCIServerVersion (void *hndlp, OCIError *errhp, OraText *bufp, + ub4 bufsz, + ub1 hndltype); + +sword OCIServerRelease (void *hndlp, OCIError *errhp, OraText *bufp, + ub4 bufsz, + ub1 hndltype, ub4 *version); + +sword OCIAttrGet (const void *trgthndlp, ub4 trghndltyp, + void *attributep, ub4 *sizep, ub4 attrtype, + OCIError *errhp); + +sword OCIAttrSet (void *trgthndlp, ub4 trghndltyp, void *attributep, + ub4 size, ub4 attrtype, OCIError *errhp); + +sword OCISvcCtxToLda (OCISvcCtx *svchp, OCIError *errhp, Lda_Def *ldap); + +sword OCILdaToSvcCtx (OCISvcCtx **svchpp, OCIError *errhp, Lda_Def *ldap); + +sword OCIResultSetToStmt (OCIResult *rsetdp, OCIError *errhp); + +sword OCIFileClose ( void *hndl, OCIError *err, OCIFileObject *filep ); + +sword OCIUserCallbackRegister(void *hndlp, ub4 type, void *ehndlp, + OCIUserCallback callback, void *ctxp, + ub4 fcode, ub4 when, OCIUcb *ucbDesc); + +sword OCIUserCallbackGet(void *hndlp, ub4 type, void *ehndlp, + ub4 fcode, ub4 when, OCIUserCallback *callbackp, + void **ctxpp, OCIUcb *ucbDesc); + +sword OCISharedLibInit(void *metaCtx, void *libCtx, ub4 argfmt, sword argc, + void **argv, OCIEnvCallbackType envCallback); + +sword OCIFileExists ( void *hndl, OCIError *err, OraText *filename, + OraText *path, ub1 *flag ); + +sword OCIFileFlush( void *hndl, OCIError *err, OCIFileObject *filep ); + + +sword OCIFileGetLength( void *hndl, OCIError *err, OraText *filename, + OraText *path, ubig_ora *lenp ); + +sword OCIFileInit ( void *hndl, OCIError *err ); + +sword OCIFileOpen ( void *hndl, OCIError *err, OCIFileObject **filep, + OraText *filename, OraText *path, ub4 mode, ub4 create, + ub4 type ); + +sword OCIFileRead ( void *hndl, OCIError *err, OCIFileObject *filep, + void *bufp, ub4 bufl, ub4 *bytesread ); + +sword OCIFileSeek ( void *hndl, OCIError *err, OCIFileObject *filep, + uword origin, ubig_ora offset, sb1 dir ); + +sword OCIFileTerm ( void *hndl, OCIError *err ); + + +sword OCIFileWrite ( void *hndl, OCIError *err, OCIFileObject *filep, + void *bufp, ub4 buflen, ub4 *byteswritten ); + + +#ifdef ORAXB8_DEFINED + +sword OCILobCopy2 (OCISvcCtx *svchp, OCIError *errhp, + OCILobLocator *dst_locp, + OCILobLocator *src_locp, oraub8 amount, + oraub8 dst_offset, + oraub8 src_offset); + +sword OCILobErase2 (OCISvcCtx *svchp, OCIError *errhp, OCILobLocator *locp, + oraub8 *amount, oraub8 offset); + +sword OCILobGetLength2 (OCISvcCtx *svchp, OCIError *errhp, + OCILobLocator *locp, oraub8 *lenp); + +sword OCILobLoadFromFile2 (OCISvcCtx *svchp, OCIError *errhp, + OCILobLocator *dst_locp, + OCILobLocator *src_filep, + oraub8 amount, oraub8 dst_offset, + oraub8 src_offset); + +sword OCILobRead2 (OCISvcCtx *svchp, OCIError *errhp, OCILobLocator *locp, + oraub8 *byte_amtp, oraub8 *char_amtp, oraub8 offset, + void *bufp, oraub8 bufl, ub1 piece, void *ctxp, + OCICallbackLobRead2 cbfp, ub2 csid, ub1 csfrm); + +sword OCILobArrayRead (OCISvcCtx *svchp, OCIError *errhp, ub4 *array_iter, + OCILobLocator **lobp_arr, oraub8 *byte_amt_arr, + oraub8 *char_amt_arr, oraub8 *offset_arr, + void **bufp_arr, oraub8 *bufl_arr, ub1 piece, + void *ctxp, OCICallbackLobArrayRead cbfp, ub2 csid, + ub1 csfrm); + +sword OCILobTrim2 (OCISvcCtx *svchp, OCIError *errhp, OCILobLocator *locp, + oraub8 newlen); + +sword OCILobWrite2 (OCISvcCtx *svchp, OCIError *errhp, OCILobLocator *locp, + oraub8 *byte_amtp, oraub8 *char_amtp, oraub8 offset, + void *bufp, oraub8 buflen, ub1 piece, void *ctxp, + OCICallbackLobWrite2 cbfp, ub2 csid, ub1 csfrm); + +sword OCILobArrayWrite (OCISvcCtx *svchp, OCIError *errhp, ub4 *array_iter, + OCILobLocator **lobp_arr, oraub8 *byte_amt_arr, + oraub8 *char_amt_arr, oraub8 *offset_arr, + void **bufp_arr, oraub8 *bufl_arr, ub1 piece, + void *ctxp, OCICallbackLobArrayWrite cbfp, ub2 csid, + ub1 csfrm); + +sword OCILobWriteAppend2 (OCISvcCtx *svchp, OCIError *errhp, + OCILobLocator *lobp, + oraub8 *byte_amtp, oraub8 *char_amtp, void *bufp, + oraub8 bufl, ub1 piece, void *ctxp, + OCICallbackLobWrite2 cbfp, ub2 csid, ub1 csfrm); + +sword OCILobGetStorageLimit (OCISvcCtx *svchp, OCIError *errhp, + OCILobLocator *lobp, oraub8 *limitp); + +sword OCILobGetOptions (OCISvcCtx *svchp, OCIError *errhp, + OCILobLocator *lobp, + ub4 optypes, void *optionsp, ub4 *optionslenp, + ub4 mode); + +sword OCILobSetOptions (OCISvcCtx *svchp, OCIError *errhp, + OCILobLocator *lobp, + ub4 optypes, void *optionsp, ub4 optionslen, + ub4 mode); + +sword OCILobGetContentType (OCISvcCtx *svchp, + OCIError *errhp, OCILobLocator *lobp, + oratext *contenttypep, ub4 *contenttypelenp, + ub4 mode); + +sword OCILobSetContentType (OCISvcCtx *svchp, + OCIError *errhp, OCILobLocator *lobp, + const oratext *contenttypep, ub4 contenttypelen, + ub4 mode); + +#endif + +/* + ** Initialize the security package + */ +sword OCISecurityInitialize (OCISecurity *sechandle, OCIError *error_handle); + +sword OCISecurityTerminate (OCISecurity *sechandle, OCIError *error_handle); + +sword OCISecurityOpenWallet(OCISecurity *osshandle, + OCIError *error_handle, + size_t wrllen, + OraText *wallet_resource_locator, + size_t pwdlen, + OraText *password, + nzttWallet *wallet); + +sword OCISecurityCloseWallet(OCISecurity *osshandle, + OCIError *error_handle, + nzttWallet *wallet); + +sword OCISecurityCreateWallet(OCISecurity *osshandle, + OCIError *error_handle, + size_t wrllen, + OraText *wallet_resource_locator, + size_t pwdlen, + OraText *password, + nzttWallet *wallet); + +sword OCISecurityDestroyWallet(OCISecurity *osshandle, + OCIError *error_handle, + size_t wrllen, + OraText *wallet_resource_locator, + size_t pwdlen, + OraText *password); + +sword OCISecurityStorePersona(OCISecurity *osshandle, + OCIError *error_handle, + nzttPersona **persona, + nzttWallet *wallet); + +sword OCISecurityOpenPersona(OCISecurity *osshandle, + OCIError *error_handle, + nzttPersona *persona); + +sword OCISecurityClosePersona(OCISecurity *osshandle, + OCIError *error_handle, + nzttPersona *persona); + +sword OCISecurityRemovePersona(OCISecurity *osshandle, + OCIError *error_handle, + nzttPersona **persona); + +sword OCISecurityCreatePersona(OCISecurity *osshandle, + OCIError *error_handle, + nzttIdentType identity_type, + nzttCipherType cipher_type, + nzttPersonaDesc *desc, + nzttPersona **persona); + +sword OCISecuritySetProtection(OCISecurity *osshandle, + OCIError *error_handle, + nzttPersona *persona, + nzttcef crypto_engine_function, + nztttdufmt data_unit_format, + nzttProtInfo *protection_info); + +sword OCISecurityGetProtection(OCISecurity *osshandle, + OCIError *error_handle, + nzttPersona *persona, + nzttcef crypto_engine_function, + nztttdufmt * data_unit_format_ptr, + nzttProtInfo *protection_info); + +sword OCISecurityRemoveIdentity(OCISecurity *osshandle, + OCIError *error_handle, + nzttIdentity **identity_ptr); + +sword OCISecurityCreateIdentity(OCISecurity *osshandle, + OCIError *error_handle, + nzttIdentType type, + nzttIdentityDesc *desc, + nzttIdentity **identity_ptr); + +sword OCISecurityAbortIdentity(OCISecurity *osshandle, + OCIError *error_handle, + nzttIdentity **identity_ptr); + +sword OCISecurityFreeIdentity(OCISecurity *osshandle, + OCIError *error_handle, + nzttIdentity **identity_ptr); + + +sword OCISecurityStoreTrustedIdentity(OCISecurity *osshandle, + OCIError *error_handle, + nzttIdentity **identity_ptr, + nzttPersona *persona); + +sword OCISecuritySign(OCISecurity *osshandle, + OCIError *error_handle, + nzttPersona *persona, + nzttces signature_state, + size_t input_length, + ub1 *input, + nzttBufferBlock *buffer_block); + +sword OCISecuritySignExpansion(OCISecurity *osshandle, + OCIError *error_handle, + nzttPersona *persona, + size_t inputlen, + size_t *signature_length); + +sword OCISecurityVerify(OCISecurity *osshandle, + OCIError *error_handle, + nzttPersona *persona, + nzttces signature_state, + size_t siglen, + ub1 *signature, + nzttBufferBlock *extracted_message, + boolean *verified, + boolean *validated, + nzttIdentity **signing_party_identity); + +sword OCISecurityValidate(OCISecurity *osshandle, + OCIError *error_handle, + nzttPersona *persona, + nzttIdentity *identity, + boolean *validated); + +sword OCISecuritySignDetached(OCISecurity *osshandle, + OCIError *error_handle, + nzttPersona *persona, + nzttces signature_state, + size_t input_length, + ub1 * input, + nzttBufferBlock *signature); + +sword OCISecuritySignDetExpansion(OCISecurity *osshandle, + OCIError *error_handle, + nzttPersona *persona, + size_t input_length, + size_t *required_buffer_length); + +sword OCISecurityVerifyDetached(OCISecurity *osshandle, + OCIError *error_handle, + nzttPersona *persona, + nzttces signature_state, + size_t data_length, + ub1 *data, + size_t siglen, + ub1 *signature, + boolean *verified, + boolean *validated, + nzttIdentity **signing_party_identity); + +sword OCISecurity_PKEncrypt(OCISecurity *osshandle, + OCIError *error_handle, + nzttPersona *persona, + size_t number_of_recipients, + nzttIdentity *recipient_list, + nzttces encryption_state, + size_t input_length, + ub1 *input, + nzttBufferBlock *encrypted_data); + +sword OCISecurityPKEncryptExpansion(OCISecurity *osshandle, + OCIError *error_handle, + nzttPersona *persona, + size_t number_recipients, + size_t input_length, + size_t *buffer_length_required); + +sword OCISecurityPKDecrypt(OCISecurity *osshandle, + OCIError *error_handle, + nzttPersona *persona, + nzttces encryption_state, + size_t input_length, + ub1 *input, + nzttBufferBlock *encrypted_data); + +sword OCISecurityEncrypt(OCISecurity *osshandle, + OCIError *error_handle, + nzttPersona *persona, + nzttces encryption_state, + size_t input_length, + ub1 *input, + nzttBufferBlock *encrypted_data); + +sword OCISecurityEncryptExpansion(OCISecurity *osshandle, + OCIError *error_handle, + nzttPersona *persona, + size_t input_length, + size_t *encrypted_data_length); + +sword OCISecurityDecrypt(OCISecurity *osshandle, + OCIError *error_handle, + nzttPersona *persona, + nzttces decryption_state, + size_t input_length, + ub1 *input, + nzttBufferBlock *decrypted_data); + +sword OCISecurityEnvelope(OCISecurity *osshandle, + OCIError *error_handle, + nzttPersona *persona, + size_t number_of_recipients, + nzttIdentity *identity, + nzttces encryption_state, + size_t input_length, + ub1 *input, + nzttBufferBlock *enveloped_data); + +sword OCISecurityDeEnvelope(OCISecurity *osshandle, + OCIError *error_handle, + nzttPersona *persona, + nzttces decryption_state, + size_t input_length, + ub1 *input, + nzttBufferBlock *output_message, + boolean *verified, + boolean *validated, + nzttIdentity **sender_identity); + +sword OCISecurityKeyedHash(OCISecurity *osshandle, + OCIError *error_handle, + nzttPersona *persona, + nzttces hash_state, + size_t input_length, + ub1 *input, + nzttBufferBlock *keyed_hash); + +sword OCISecurityKeyedHashExpansion(OCISecurity *osshandle, + OCIError *error_handle, + nzttPersona *persona, + size_t input_length, + size_t *required_buffer_length); + +sword OCISecurityHash(OCISecurity *osshandle, + OCIError *error_handle, + nzttPersona *persona, + nzttces hash_state, + size_t input, + ub1 *input_length, + nzttBufferBlock *hash); + +sword OCISecurityHashExpansion(OCISecurity *osshandle, + OCIError *error_handle, + nzttPersona *persona, + size_t input_length, + size_t *required_buffer_length); + +sword OCISecuritySeedRandom(OCISecurity *osshandle, + OCIError *error_handle, + nzttPersona *persona, + size_t seed_length, + ub1 *seed); + +sword OCISecurityRandomBytes(OCISecurity *osshandle, + OCIError *error_handle, + nzttPersona *persona, + size_t number_of_bytes_desired, + nzttBufferBlock *random_bytes); + +sword OCISecurityRandomNumber(OCISecurity *osshandle, + OCIError *error_handle, + nzttPersona *persona, + uword *random_number_ptr); + +sword OCISecurityInitBlock(OCISecurity *osshandle, + OCIError *error_handle, + nzttBufferBlock *buffer_block); + +sword OCISecurityReuseBlock(OCISecurity *osshandle, + OCIError *error_handle, + nzttBufferBlock *buffer_block); + +sword OCISecurityPurgeBlock(OCISecurity *osshandle, + OCIError *error_handle, + nzttBufferBlock *buffer_block); + +sword OCISecuritySetBlock(OCISecurity *osshandle, + OCIError *error_handle, + uword flags_to_set, + size_t buffer_length, + size_t used_buffer_length, + ub1 *buffer, + nzttBufferBlock *buffer_block); + +sword OCISecurityGetIdentity(OCISecurity *osshandle, + OCIError *error_handle, + size_t namelen, + OraText *distinguished_name, + nzttIdentity **identity); + +sword OCIAQEnq(OCISvcCtx *svchp, OCIError *errhp, OraText *queue_name, + OCIAQEnqOptions *enqopt, OCIAQMsgProperties *msgprop, + OCIType *payload_tdo, void **payload, void **payload_ind, + OCIRaw **msgid, ub4 flags); + +sword OCIAQDeq(OCISvcCtx *svchp, OCIError *errhp, OraText *queue_name, + OCIAQDeqOptions *deqopt, OCIAQMsgProperties *msgprop, + OCIType *payload_tdo, void **payload, void **payload_ind, + OCIRaw **msgid, ub4 flags); + +sword OCIAQEnqArray(OCISvcCtx *svchp, OCIError *errhp, OraText *queue_name, + OCIAQEnqOptions *enqopt, ub4 *iters, + OCIAQMsgProperties **msgprop, OCIType *payload_tdo, + void **payload, void **payload_ind, OCIRaw **msgid, + void *ctxp, OCICallbackAQEnq enqcbfp, ub4 flags); + +sword OCIAQEnqStreaming(OCISvcCtx *svchp, OCIError *errhp, OraText *queue_name, + OCIAQEnqOptions *enqopt, OCIType *payload_tdo, + void *ctxp, OCICallbackAQEnqStreaming enqcbfp, + ub4 flags); + +sword OCIAQDeqArray(OCISvcCtx *svchp, OCIError *errhp, OraText *queue_name, + OCIAQDeqOptions *deqopt, ub4 *iters, + OCIAQMsgProperties **msgprop, OCIType *payload_tdo, + void **payload, void **payload_ind, OCIRaw **msgid, + void *ctxp, OCICallbackAQDeq deqcbfp, ub4 flags); + +sword OCIAQListen(OCISvcCtx *svchp, OCIError *errhp, + OCIAQAgent **agent_list, ub4 num_agents, + sb4 wait, OCIAQAgent **agent, + ub4 flags); + +sword OCIAQListen2(OCISvcCtx *svchp, OCIError *errhp, + OCIAQAgent **agent_list, ub4 num_agents, + OCIAQListenOpts *lopts, OCIAQAgent **agent, + OCIAQLisMsgProps *lmops, ub4 flags); + +sword OCIAQGetReplayInfo(OCISvcCtx *svchp, OCIError *errhp, + OraText *queue_name, OCIAQAgent *sender, + ub4 replay_attribute, OraText *correlation, + ub2 *corr_len); + +sword OCIAQResetReplayInfo(OCISvcCtx *svchp, OCIError *errhp, + OraText *queue_name, OCIAQAgent *sender, + ub4 replay_attribute); + +sword OCIExtractInit(void *hndl, OCIError *err); + +sword OCIExtractTerm(void *hndl, OCIError *err); + +sword OCIExtractReset(void *hndl, OCIError *err); + +sword OCIExtractSetNumKeys(void *hndl, OCIError *err, uword numkeys); + +sword OCIExtractSetKey(void *hndl, OCIError *err, const OraText *name, + ub1 type, ub4 flag, const void *defval, + const sb4 *intrange, const OraText *const *strlist); + +sword OCIExtractFromFile(void *hndl, OCIError *err, ub4 flag, + OraText *filename); + +sword OCIExtractFromStr(void *hndl, OCIError *err, ub4 flag, OraText *input); + +sword OCIExtractToInt(void *hndl, OCIError *err, OraText *keyname, + uword valno, sb4 *retval); + +sword OCIExtractToBool(void *hndl, OCIError *err, OraText *keyname, + uword valno, ub1 *retval); + +sword OCIExtractToStr(void *hndl, OCIError *err, OraText *keyname, + uword valno, OraText *retval, uword buflen); + +sword OCIExtractToOCINum(void *hndl, OCIError *err, OraText *keyname, + uword valno, OCINumber *retval); + +sword OCIExtractToList(void *hndl, OCIError *err, uword *numkeys); + +sword OCIExtractFromList(void *hndl, OCIError *err, uword index, + OraText **name, + ub1 *type, uword *numvals, void ***values); + +/* Memory Related Service Interfaces */ + +sword OCIMemoryAlloc(void *hdl, OCIError *err, void **mem, + OCIDuration dur, ub4 size, ub4 flags); + +sword OCIMemoryResize(void *hdl, OCIError *err, void **mem, + ub4 newsize, ub4 flags); + +sword OCIMemoryFree(void *hdl, OCIError *err, void *mem); + +sword OCIContextSetValue(void *hdl, OCIError *err, OCIDuration duration, + ub1 *key, ub1 keylen, void *ctx_value); + +sword OCIContextGetValue(void *hdl, OCIError *err, ub1 *key, + ub1 keylen, void **ctx_value); + +sword OCIContextClearValue(void *hdl, OCIError *err, ub1 *key, + ub1 keylen); + +sword OCIContextGenerateKey(void *hdl, OCIError *err, ub4 *key); + +sword OCIMemorySetCurrentIDs(void *hdl, OCIError *err, + ub4 curr_session_id, ub4 curr_trans_id, + ub4 curr_stmt_id); + +sword OCIPicklerTdsCtxInit(OCIEnv *env, OCIError *err, + OCIPicklerTdsCtx **tdsc); + +sword OCIPicklerTdsCtxFree(OCIEnv *env, OCIError *err, OCIPicklerTdsCtx *tdsc); + +sword OCIPicklerTdsInit(OCIEnv *env, OCIError *err, OCIPicklerTdsCtx *tdsc, + OCIPicklerTds **tdsh); + +sword OCIPicklerTdsFree(OCIEnv *env, OCIError *err, OCIPicklerTds *tdsh); + +sword OCIPicklerTdsCreateElementNumber(OCIEnv *env, OCIError *err, + OCIPicklerTds *tdsh, ub1 prec, + sb1 scale, OCIPicklerTdsElement *elt); + +sword OCIPicklerTdsCreateElementChar(OCIEnv *env, OCIError *err, + OCIPicklerTds *tdsh, ub2 len, + OCIPicklerTdsElement *elt); + +sword OCIPicklerTdsCreateElementVarchar(OCIEnv *env, OCIError *err, + OCIPicklerTds *tdsh, ub2 len, + OCIPicklerTdsElement *elt); + +sword OCIPicklerTdsCreateElementRaw(OCIEnv *env, OCIError *err, + OCIPicklerTds *tdsh, ub2 len, + OCIPicklerTdsElement *elt); + +sword OCIPicklerTdsCreateElement(OCIEnv *env, OCIError *err, + OCIPicklerTds *tdsh, OCITypeCode dty, + OCIPicklerTdsElement *elt); + +sword OCIPicklerTdsAddAttr(OCIEnv *env, OCIError *err, + OCIPicklerTds *tdsh, OCIPicklerTdsElement elt); + +sword OCIPicklerTdsGenerate(OCIEnv *env, OCIError *err, + OCIPicklerTds *tdsh); + +sword OCIPicklerTdsGetAttr(OCIEnv *env, OCIError *err, + const OCIPicklerTds *tdsh, ub1 attrno, + OCITypeCode *typ, ub2 *len); + +sword OCIPicklerFdoInit(OCIEnv *env, OCIError *err, + OCIPicklerFdo **fdoh); + +sword OCIPicklerFdoFree(OCIEnv *env, OCIError *err, + OCIPicklerFdo *fdoh); + +sword OCIPicklerImageInit(OCIEnv *env, OCIError *err, + OCIPicklerFdo *fdoh, + OCIPicklerTds *tdsh, + OCIPicklerImage **imgh); + +sword OCIPicklerImageFree(OCIEnv *env, OCIError *err, + OCIPicklerImage *imgh); + +sword OCIPicklerImageAddScalar(OCIEnv *env, OCIError *err, + OCIPicklerImage *imgh, + void *scalar, ub4 len); + +sword OCIPicklerImageAddNullScalar(OCIEnv *env, OCIError *err, + OCIPicklerImage *imgh); + +sword OCIPicklerImageGenerate(OCIEnv *env, OCIError *err, + OCIPicklerImage *imgh); + +sword OCIPicklerImageGetScalarSize(OCIEnv *env, OCIError *err, + OCIPicklerImage *imgh, + ub4 attrno, ub4 *size); + +sword OCIPicklerImageGetScalar(OCIEnv *env, OCIError *err, + OCIPicklerImage *imgh, ub4 attrno, + void *buf, ub4 *len, OCIInd *ind); + +sword OCIPicklerImageCollBegin(OCIEnv *env, OCIError *err, + OCIPicklerImage *imgh, const OCIPicklerTds *colltdsh); + +sword OCIPicklerImageCollAddScalar( OCIEnv *env, OCIError *err, + OCIPicklerImage *imgh, void *scalar, + ub4 buflen, OCIInd ind); + +sword OCIPicklerImageCollEnd(OCIEnv *env, OCIError *err, + OCIPicklerImage *imgh); + +/* should take svcctx for locator stuff */ +sword OCIPicklerImageCollBeginScan(OCIEnv *env, OCIError *err, + OCIPicklerImage *imgh, const OCIPicklerTds *coll_tdsh, + ub4 attrnum, ub4 startidx, OCIInd *ind); + +sword OCIPicklerImageCollGetScalarSize(OCIEnv *env, OCIError *err, + const OCIPicklerTds *coll_tdsh, ub4 *size); + +sword OCIPicklerImageCollGetScalar(OCIEnv *env, OCIError *err, + OCIPicklerImage *imgh, void *buf, + ub4 *buflen, OCIInd *ind); + +sword OCIAnyDataGetType(OCISvcCtx *svchp, OCIError *errhp, OCIAnyData *sdata, + OCITypeCode *tc, OCIType **type); + +sword OCIAnyDataIsNull(OCISvcCtx *svchp, OCIError *errhp, OCIAnyData *sdata, + boolean *isnull); + +sword OCIAnyDataConvert(OCISvcCtx *svchp, OCIError *errhp, OCITypeCode tc, + OCIType *type, OCIDuration dur, void *ind, void *data_val, + ub4 len, OCIAnyData **sdata); + +sword OCIAnyDataBeginCreate(OCISvcCtx *svchp, OCIError *errhp, OCITypeCode tc, + OCIType *type, OCIDuration dur, OCIAnyData **sdata); + +sword OCIAnyDataDestroy(OCISvcCtx *svchp, OCIError *errhp, OCIAnyData *sdata); + +sword OCIAnyDataAttrSet(OCISvcCtx *svchp, OCIError *errhp, OCIAnyData *sdata, + OCITypeCode tc, OCIType *type, void *ind, void *attr_val, + ub4 length, boolean is_any); + +sword OCIAnyDataCollAddElem(OCISvcCtx *svchp, OCIError *errhp, + OCIAnyData *sdata, OCITypeCode tc, OCIType *type, void *ind, + void *attr_val, ub4 length, boolean is_any, boolean last_elem); + +sword OCIAnyDataEndCreate(OCISvcCtx *svchp, OCIError *errhp, + OCIAnyData *sdata); + +sword OCIAnyDataAccess(OCISvcCtx *svchp, OCIError *errhp, OCIAnyData *sdata, + OCITypeCode tc, OCIType *type, void *ind, void *attr_val, + ub4 *length); + +sword OCIAnyDataGetCurrAttrNum(OCISvcCtx *svchp, OCIError *errhp, + OCIAnyData *sdata, ub4 *attrnum); + +sword OCIAnyDataAttrGet(OCISvcCtx *svchp, OCIError *errhp, OCIAnyData *sdata, + OCITypeCode tc, OCIType *type, void *ind, void *attr_val, + ub4 *length, boolean is_any); + +sword OCIAnyDataCollGetElem(OCISvcCtx *svchp, OCIError *errhp, + OCIAnyData *sdata, + OCITypeCode tc, OCIType *type, void *ind, void *celem_val, + ub4 *length, boolean is_any); + + +/*------------------------ OCIAnyDataSet interfaces -------------------------*/ + +/* + NAME + OCIAnyDataSetBeginCreate - OCIAnyDataSet Begin Creation + PARAMETERS + svchp (IN/OUT) - The OCI service context. + errhp (IN/OUT) - The OCI error handle. If there is an error, it is + recorded in errhp and this function returns OCI_ERROR. + Diagnostic information can be obtained by calling + OCIErrorGet(). + typecode - typecode corresponding to the OCIAnyDataSet. + type (IN) - type corresponding to the OCIAnyDataSet. If the typecode + corresponds to a built-in type (OCI_TYPECODE_NUMBER etc.) + , this parameter can be NULL. It should be non NULL for + user defined types (OCI_TYPECODE_OBJECT, + OCI_TYPECODE_REF, collection types etc.) + dur (IN) - duration for which OCIAnyDataSet is allocated. + data_set (OUT) - Initialized OCIAnyDataSet. + RETURNS - error code + NOTES + This call allocates an OCIAnyDataSet for the duration of dur and + initializes it with the type information. The OCIAnyDataSet can hold + multiple instances of the given type. For performance reasons, the + OCIAnyDataSet will end up pointing to the passed in OCIType parameter. + It is the responsibility of the caller to ensure that the OCIType is + longer lived (has allocation duration >= the duration of the OCIAnyData + if the OCIType is a transient one, allocation/pin duration >= duration of + the OCIAnyData if the OCIType is a persistent one). + +*/ +sword OCIAnyDataSetBeginCreate(OCISvcCtx *svchp, OCIError *errhp, + OCITypeCode typecode, const OCIType *type, OCIDuration dur, + OCIAnyDataSet ** data_set); + +/* + NAME + OCIAnyDataSetDestroy - OCIAnyDataSet Destroy + DESCRIPTION + This call frees the OCIAnyDataSet allocated using + OCIAnyDataSetBeginCreate(). + RETURNS + error code. + PARAMETERS + svchp (IN/OUT) - The OCI service context. + errhp (IN/OUT) - The OCI Error handle. + data_set (IN/OUT) - OCIAnyDataSet to be freed. +*/ +sword OCIAnyDataSetDestroy(OCISvcCtx *svchp, OCIError *errhp, + OCIAnyDataSet *data_set); + + +/* + NAME + OCIAnyDataSetAddInstance - OCIAnyDataSet Add an instance + DESCRIPTION + This call adds a new skeleton instance to the OCIAnyDataSet and all the + attributes of the instance are set to NULL. It returns this skeleton + instance through the OCIAnyData parameter which can be constructed + subsequently by invoking the OCIAnyData API. + RETURNS + error code. + PARAMETERS + svchp (IN/OUT) - The OCI service context. + errhp (IN/OUT) - The OCI Error handle. + data_set (IN/OUT) - OCIAnyDataSet to which a new instance is added. + data (IN/OUT) - OCIAnyData corresponding to the newly added + instance. If (*data) is NULL, a new OCIAnyData will + be allocated for same duration as the OCIAnyDataSet. + If (*data) is not NULL, it will get reused. This + OCIAnyData can be subseqently constructed using the + OCIAnyDataConvert() call or it can be constructed + piece-wise using the OCIAnyDataAttrSet and + OCIAnyDataCollAddElem calls. + NOTES + No Destruction of the old value is done here. It is the responsibility of + the caller to destroy the old value pointed to by (*data) and set (*data) + to a null pointer before beginning to make a sequence of this call. No + deep copying (of OCIType information nor the data part.) is done in the + returned OCIAnyData. This OCIAnyData cannot be used beyond the allocation + duration of the OCIAnyDataSet (it is like a reference into the + OCIAnyDataSet). The returned OCIAnyData can be reused on subsequent calls + to this function, to sequentially add new data instances to the + OCIAnyDataSet. +*/ +sword OCIAnyDataSetAddInstance(OCISvcCtx *svchp, OCIError *errhp, + OCIAnyDataSet *data_set, OCIAnyData **data); + +/* + NAME + OCIAnyDataSetEndCreate - OCIAnyDataSet End Creation process. + DESCRIPTION + This call marks the end of OCIAnyDataSet creation. It should be called + after constructing all of its instance(s). + RETURNS + error code. + PARAMETERS + svchp (IN/OUT) - The OCI service context. + errhp (IN/OUT) - The OCI error handle. If there is an error, it is + recorded in errhp and this function returns + OCI_ERROR. Diagnostic information can be obtained + by calling OCIErrorGet(). + data_set (IN/OUT) - OCIAnyDataSet that has been fully constructed. +*/ +sword OCIAnyDataSetEndCreate(OCISvcCtx *svchp, OCIError *errhp, + OCIAnyDataSet *data_set); + +/* + NAME + OCIAnyDataSetGetType - OCIAnyDataSet Get Type of an OCIAnyDataSet + DESCRIPTION + Gets the Type corresponding to an OCIAnyDataSet. It returns the actual + pointer to the type maintained inside an OCIAnyDataSet. No copying is + done for performance reasons. The client is responsible for not using + this type once the OCIAnyDataSet is freed (or its duration ends). + RETURNS + error code. + PARAMETERS + svchp (IN/OUT) - The OCI service context. + errhp (IN/OUT) - The OCI Error handle. + data_set (IN) - Initialized OCIAnyDataSet. + tc (OUT) - The typecode of the type. + type (OUT) - The type corresponding to the OCIAnyDataSet. This + could be null if the OCIAnyData corresponds to a + built-in type. +*/ +sword OCIAnyDataSetGetType (OCISvcCtx *svchp, OCIError *errhp, + OCIAnyDataSet *data_set, OCITypeCode *tc, OCIType **type); + +/* + NAME + OCIAnyDataSetGetCount - OCIAnyDataSet Get Count of instances. + DESCRIPTION + This call gets the number of instances in the OCIAnyDataSet. + RETURNS + error code. + PARAMETERS + svchp (IN/OUT) - OCI Service Context + errhp (IN/OUT) - OCI Error handle + data_set (IN) - Well formed OCIAnyDataSet. + count (OUT) - number of instances in OCIAnyDataSet +*/ +sword OCIAnyDataSetGetCount(OCISvcCtx *svchp, OCIError *errhp, + OCIAnyDataSet *data_set, ub4 *count); + +/* + NAME + OCIAnyDataSetGetInstance - OCIAnyDataSet Get next instance. + DESCRIPTION + Only sequential access to the instances in an OCIAnyDataSet is allowed. + This call returns the OCIAnyData corresponding to an instance at the + current position and updates the current position. Subsequently, the + OCIAnyData access routines may be used to access the instance. + RETURNS + error code. Returns OCI_NO_DATA if the current position is at the end of + the set, OCI_SUCCESS otherwise. + PARAMETERS + svchp (IN/OUT) - OCI Service Context + errhp (IN/OUT) - OCI Error handle + data_set (IN) - Well formed OCIAnyDataSet + data (IN/OUT) - OCIAnyData corresponding to the instance. If (*data) + is NULL, a new OCIAnyData will be allocated for same + duration as the OCIAnyDataSet. If (*data) is not NULL + , it will get reused. This OCIAnyData can be + subsequently accessed using the OCIAnyDataAccess() + call or piece-wise by using the OCIAnyDataAttrGet() + call. + NOTE + No Destruction of the old value is done here. It is the responsibility of + the caller to destroy the old value pointed to by (*data) and set (*data) + to a null pointer before beginning to make a sequence of this call. No deep + copying (of OCIType information nor the data part.) is done in the returned + OCIAnyData. This OCIAnyData cannot be used beyond the allocation duration + of the OCIAnyDataSet (it is like a reference into the OCIAnyDataSet). The + returned OCIAnyData can be reused on subsequent calls to this function to + sequentially access the OCIAnyDataSet. +*/ +sword OCIAnyDataSetGetInstance(OCISvcCtx *svchp, OCIError *errhp, + OCIAnyDataSet *data_set, OCIAnyData **data); + +/*--------------------- End of OCIAnyDataSet interfaces ---------------------*/ + +sword OCIFormatInit(void *hndl, OCIError *err); + +sword OCIFormatString(void *hndl, OCIError *err, OraText *buffer, + sbig_ora bufferLength, sbig_ora *returnLength, + const OraText *formatString, ...); + +sword OCIFormatTerm(void *hndl, OCIError *err); + +sword OCIFormatTUb1(void); +sword OCIFormatTUb2(void); +sword OCIFormatTUb4(void); +sword OCIFormatTUword(void); +sword OCIFormatTUbig_ora(void); +sword OCIFormatTSb1(void); +sword OCIFormatTSb2(void); +sword OCIFormatTSb4(void); +sword OCIFormatTSword(void); +sword OCIFormatTSbig_ora(void); +sword OCIFormatTEb1(void); +sword OCIFormatTEb2(void); +sword OCIFormatTEb4(void); +sword OCIFormatTEword(void); +sword OCIFormatTChar(void); +sword OCIFormatTText(void); +sword OCIFormatTDouble(void); +sword OCIFormatTDvoid(void); +sword OCIFormatTEnd(void); + +/*-------------------------- Extensions to XA interface ---------------------*/ +/* ------------------------- xaosvch ----------------------------------------*/ +/* + NAME + xaosvch - XA Oracle get SerViCe Handle + DESCRIPTION + Given a database name return the service handle that is used by the + XA library + NOTE + This macro has been provided for backward compatibilty with 8.0.2 +*/ +OCISvcCtx *xaosvch(OraText *dbname); + +/* ------------------------- xaoSvcCtx --------------------------------------*/ +/* + NAME + xaoSvcCtx - XA Oracle get SerViCe ConTeXt + DESCRIPTION + Given a database name return the service handle that is used by the + XA library + NOTE + This routine has been provided for APs to get access to the service + handle that XA library uses. Without this routine APs must use SQLLIB + routine sqlld2 to get access to the Logon data area registered by the + XA library +*/ +OCISvcCtx *xaoSvcCtx(OraText *dbname); + +/* ------------------------- xaoEnv -----------------------------------------*/ +/* + NAME + xaoEnv - XA Oracle get ENvironment Handle + DESCRIPTION + Given a database name return the environment handle that is used by the + XA library + NOTE + This routine has been provided for APs to get access to the environment + handle that XA library uses. Without this routine APs must use SQLLIB + routine sqlld2 to get access to the Logon data area registered by the + XA library +*/ +OCIEnv *xaoEnv(OraText *dbname); + +/* ------------------------- xaosterr ---------------------------------------*/ +/* + NAME + xaosterr - XA Oracle get xa STart ERRor code + DESCRIPTION + Given an oracle error code return the XA error code + */ +int xaosterr(OCISvcCtx *svch, sb4 error); +/*-------------------------- End Extensions ---------------------------------*/ +/*---------------------- Extensions to NLS cartridge service ----------------*/ +/* ----------------------- OCINlsGetInfo ------------------------------------*/ +/* + NAME + OCINlsGetInfo - Get NLS info from OCI environment handle + REMARKS + This function generates language information specified by item from OCI + environment handle envhp into an array pointed to by buf within size + limitation as buflen. + RETURNS + OCI_SUCCESS, OCI_INVALID_HANDLE, or OCI_ERROR on wrong item. + envhp(IN/OUT) + OCI environment handle. + errhp(IN/OUT) + The OCI error handle. If there is an error, it is record in errhp and + this function returns a NULL pointer. Diagnostic information can be + obtained by calling OCIErrorGet(). + buf(OUT) + Pointer to the destination buffer. + buflen(IN) + The size of destination buffer. The maximum length for each information + is 32 bytes. + item(IN) + It specifies to get which item in OCI environment handle and can be one + of following values: + OCI_NLS_DAYNAME1 : Native name for Monday. + OCI_NLS_DAYNAME2 : Native name for Tuesday. + OCI_NLS_DAYNAME3 : Native name for Wednesday. + OCI_NLS_DAYNAME4 : Native name for Thursday. + OCI_NLS_DAYNAME5 : Native name for Friday. + OCI_NLS_DAYNAME6 : Native name for for Saturday. + OCI_NLS_DAYNAME7 : Native name for for Sunday. + OCI_NLS_ABDAYNAME1 : Native abbreviated name for Monday. + OCI_NLS_ABDAYNAME2 : Native abbreviated name for Tuesday. + OCI_NLS_ABDAYNAME3 : Native abbreviated name for Wednesday. + OCI_NLS_ABDAYNAME4 : Native abbreviated name for Thursday. + OCI_NLS_ABDAYNAME5 : Native abbreviated name for Friday. + OCI_NLS_ABDAYNAME6 : Native abbreviated name for for Saturday. + OCI_NLS_ABDAYNAME7 : Native abbreviated name for for Sunday. + OCI_NLS_MONTHNAME1 : Native name for January. + OCI_NLS_MONTHNAME2 : Native name for February. + OCI_NLS_MONTHNAME3 : Native name for March. + OCI_NLS_MONTHNAME4 : Native name for April. + OCI_NLS_MONTHNAME5 : Native name for May. + OCI_NLS_MONTHNAME6 : Native name for June. + OCI_NLS_MONTHNAME7 : Native name for July. + OCI_NLS_MONTHNAME8 : Native name for August. + OCI_NLS_MONTHNAME9 : Native name for September. + OCI_NLS_MONTHNAME10 : Native name for October. + OCI_NLS_MONTHNAME11 : Native name for November. + OCI_NLS_MONTHNAME12 : Native name for December. + OCI_NLS_ABMONTHNAME1 : Native abbreviated name for January. + OCI_NLS_ABMONTHNAME2 : Native abbreviated name for February. + OCI_NLS_ABMONTHNAME3 : Native abbreviated name for March. + OCI_NLS_ABMONTHNAME4 : Native abbreviated name for April. + OCI_NLS_ABMONTHNAME5 : Native abbreviated name for May. + OCI_NLS_ABMONTHNAME6 : Native abbreviated name for June. + OCI_NLS_ABMONTHNAME7 : Native abbreviated name for July. + OCI_NLS_ABMONTHNAME8 : Native abbreviated name for August. + OCI_NLS_ABMONTHNAME9 : Native abbreviated name for September. + OCI_NLS_ABMONTHNAME10 : Native abbreviated name for October. + OCI_NLS_ABMONTHNAME11 : Native abbreviated name for November. + OCI_NLS_ABMONTHNAME12 : Native abbreviated name for December. + OCI_NLS_YES : Native string for affirmative response. + OCI_NLS_NO : Native negative response. + OCI_NLS_AM : Native equivalent string of AM. + OCI_NLS_PM : Native equivalent string of PM. + OCI_NLS_AD : Native equivalent string of AD. + OCI_NLS_BC : Native equivalent string of BC. + OCI_NLS_DECIMAL : decimal character. + OCI_NLS_GROUP : group separator. + OCI_NLS_DEBIT : Native symbol of debit. + OCI_NLS_CREDIT : Native sumbol of credit. + OCI_NLS_DATEFORMAT : Oracle date format. + OCI_NLS_INT_CURRENCY: International currency symbol. + OCI_NLS_LOC_CURRENCY : Locale currency symbol. + OCI_NLS_LANGUAGE : Language name. + OCI_NLS_ABLANGUAGE : Abbreviation for language name. + OCI_NLS_TERRITORY : Territory name. + OCI_NLS_CHARACTER_SET : Character set name. + OCI_NLS_LINGUISTIC : Linguistic name. + OCI_NLS_CALENDAR : Calendar name. + OCI_NLS_DUAL_CURRENCY : Dual currency symbol. +*/ +sword OCINlsGetInfo(void *envhp, OCIError *errhp, OraText *buf, + size_t buflen, ub2 item); + +/* ----------------------- OCINlsNumericInfoGet -----------------------------*/ +/* + NAME + OCINlsNumericInfoGet - Get NLS numeric info from OCI environment handle + REMARKS + This function generates numeric language information specified by item + from OCI environment handle envhp into an output number variable. + RETURNS + OCI_SUCCESS, OCI_INVALID_HANDLE, or OCI_ERROR on wrong item. + envhp(IN/OUT) + OCI environment handle. If handle invalid, returns OCI_INVALID_HANDLE. + errhp(IN/OUT) + The OCI error handle. If there is an error, it is record in errhp and + this function returns a NULL pointer. Diagnostic information can be + obtained by calling OCIErrorGet(). + val(OUT) + Pointer to the output number variable. On OCI_SUCCESS return, it will + contain the requested NLS numeric info. + item(IN) + It specifies to get which item in OCI environment handle and can be one + of following values: + OCI_NLS_CHARSET_MAXBYTESZ : Maximum character byte size for OCI + environment or session handle charset + OCI_NLS_CHARSET_FIXEDWIDTH: Character byte size for fixed-width charset; + 0 for variable-width charset +*/ +sword OCINlsNumericInfoGet(void *envhp, OCIError *errhp, sb4 *val, ub2 item); + +/* ----------------------- OCINlsCharSetNameToId ----------------------------*/ +/* + NAME + OCINlsCharSetNameToId - Get Oracle charset id given Oracle charset name + REMARKS + This function will get the Oracle character set id corresponding to + the given Oracle character set name. + RETURNS + Oracle character set id for the given Oracle character set name if + character set name and OCI handle are valid; otherwise returns 0. + envhp(IN/OUT) + OCI environment handle. + name(IN) + Pointer to a null-terminated Oracle character set name whose id + will be returned. +*/ +ub2 OCINlsCharSetNameToId(void *envhp, const oratext *name); + +/* ----------------------- OCINlsCharSetIdToName ----------------------------*/ +/* + NAME + OCINlsCharSetIdToName - Get Oracle charset name given Oracle charset id + REMARKS + This function will get the Oracle character set name corresponding to + the given Oracle character set id. + RETURNS + OCI_SUCCESS, OCI_INVALID_HANDLE, or OCI_ERROR + envhp(IN/OUT) + OCI environment handle. If handle invalid, returns OCI_INVALID_HANDLE. + buf(OUT) + Pointer to the destination buffer. On OCI_SUCCESS return, it will contain + the null-terminated string for character set name. + buflen(IN) + Size of destination buffer. Recommended size is OCI_NLS_MAXBUFSZ for + guarantee to store an Oracle character set name. If it's smaller than + the length of the character set name, the function will return OCI_ERROR. + id(IN) + Oracle character set id. +*/ +sword OCINlsCharSetIdToName(void *envhp, oratext *buf, size_t buflen, ub2 id); + +/* ----------------------- OCINlsNameMap ------------------------------------*/ +/* + NAME + OCINlsNameMap - Map NLS naming from Oracle to other standards and vice + versa + REMARKS + This function will map NLS naming from Oracle to other standards (such + as ISO, IANA) and vice versa. + RETURNS + OCI_SUCCESS, OCI_INVALID_HANDLE, or OCI_ERROR + envhp(IN/OUT) + OCI environment handle. If handle invalid, returns OCI_INVALID_HANDLE. + buf(OUT) + Pointer to the destination buffer. On OCI_SUCCESS return, it will + contain null-terminated string for requested mapped name. + buflen(IN) + The size of destination buffer. Recommended size is OCI_NLS_MAXBUFSZ + for guarantee to store an NLS name. If it is smaller than the length + of the name, the function will return OCI_ERROR. + srcbuf(IN) + Pointer to null-terminated NLS name. If it is not a valid name in its + define scope, the function will return OCI_ERROR. + flag(IN) + It specifies name mapping direction and can take the following values: + OCI_NLS_CS_IANA_TO_ORA : Map character set name from IANA to Oracle + OCI_NLS_CS_ORA_TO_IANA : Map character set name from Oracle to IANA + OCI_NLS_LANG_ISO_TO_ORA : Map language name from ISO to Oracle + OCI_NLS_LANG_ORA_TO_ISO : Map language name from Oracle to ISO + OCI_NLS_TERR_ISO_TO_ORA : Map territory name from ISO to Oracle + OCI_NLS_TERR_ORA_TO_ISO : Map territory name from Oracle to ISO + OCI_NLS_TERR_ISO3_TO_ORA : Map territory name from 3-letter ISO + abbreviation to Oracle + OCI_NLS_TERR_ORA_TO_ISO3 : Map territory name from Oracle to 3-letter + ISO abbreviation +*/ +sword OCINlsNameMap(void *envhp, oratext *buf, size_t buflen, + const oratext *srcbuf, ub4 flag); + +/* -------------------- OCIMultiByteToWideChar ------------------------------*/ +/* + NAME + OCIMultiByteToWideChar - Convert a null terminated multibyte string into + wchar + REMARKS + This routine converts an entire null-terminated string into the wchar + format. The wchar output buffer will be null-terminated. + RETURNS + OCI_SUCCESS, OCI_INVALID_HANDLE or OCI_ERROR + envhp(IN/OUT) + OCI environment handle to determine the character set of string. + dst (OUT) + Destination buffer for wchar. + src (IN) + Source string to be converted. + rsize (OUT) + Number of characters converted including null-terminator. + If it is a NULL pointer, no number return +*/ +sword OCIMultiByteToWideChar(void *envhp, OCIWchar *dst, const OraText *src, + size_t *rsize); + + +/* --------------------- OCIMultiByteInSizeToWideChar -----------------------*/ +/* + NAME + OCIMultiByteInSizeToWideChar - Convert a mulitbyte string in length into + wchar + REMARKS + This routine converts part of string into the wchar format. It will + convert as many complete characters as it can until it reaches output + buffer size or input buffer size or it reaches a null-terminator in + source string. The output buffer will be null-terminated if space permits. + If dstsz is zero, this function will only return number of characters not + including ending null terminator for converted string. + RETURNS + OCI_SUCCESS, OCI_INVALID_HANDLE or OCI_ERROR + envhp(IN/OUT) + OCI environment handle to determine the character set of string. + dst (OUT) + Pointer to a destination buffer for wchar. It can be NULL pointer when + dstsz is zero. + dstsz(IN) + Destination buffer size in character. If it is zero, this function just + returns number of characters will be need for the conversion. + src (IN) + Source string to be converted. + srcsz(IN) + Length of source string in byte. + rsize(OUT) + Number of characters written into destination buffer, or number of + characters for converted string is dstsz is zero. + If it is NULL pointer, nothing to return. +*/ +sword OCIMultiByteInSizeToWideChar(void *envhp, OCIWchar *dst, + size_t dstsz, const OraText *src, + size_t srcsz, size_t *rsize); + + +/* ---------------------- OCIWideCharToMultiByte ----------------------------*/ +/* + NAME + OCIWideCharToMultiByte - Convert a null terminated wchar string into + multibyte + REMARKS + This routine converts an entire null-terminated wide character string into + multi-byte string. The output buffer will be null-terminated. + RETURNS + OCI_SUCCESS, OCI_INVALID_HANDLE or OCI_ERROR + envhp(IN/OUT) + OCI environment handle to determine the character set of string. + dst (OUT) + Destination buffer for multi-byte string. + src (IN) + Source wchar string to be converted. + rsize (OUT) + Number of bytes written into the destination buffer. + If it is NULL pointer, nothing to return. +*/ +sword OCIWideCharToMultiByte(void *envhp, OraText *dst, const OCIWchar *src, + size_t *rsize); + + +/* ---------------------- OCIWideCharInSizeToMultiByte ----------------------*/ +/* + NAME + OCIWideCharInSizeToMultiByte - Convert a wchar string in length into + mulitbyte + REMARKS + This routine converts part of wchar string into the multi-byte format. + It will convert as many complete characters as it can until it reaches + output buffer size or input buffer size or it reaches a null-terminator + in source string. The output buffer will be null-terminated if space + permits. If dstsz is zero, the function just returns the size of byte not + including ending null-terminator need to store the converted string. + RETURNS + OCI_SUCCESS, OCI_INVALID_HANDLE or OCI_ERROR + envhp(IN/OUT) + OCI environment handle to determine the character set of string. + dst (OUT) + Destination buffer for multi-byte. It can be NULL pointer if dstsz is + zero. + dstsz(IN) + Destination buffer size in byte. If it is zero, it just returns the size + of bytes need for converted string. + src (IN) + Source wchar string to be converted. + srcsz(IN) + Length of source string in character. + rsize(OUT) + Number of bytes written into destination buffer, or number of bytes need + to store the converted string if dstsz is zero. + If it is NULL pointer, nothing to return. +*/ +sword OCIWideCharInSizeToMultiByte(void *envhp, OraText *dst, + size_t dstsz, const OCIWchar *src, + size_t srcsz, size_t *rsize); + + + +/* ----------------------- OCIWideCharIsAlnum -------------------------------*/ +/* + NAME + OCIWideCharIsAlnum - test whether wc is a letter or decimal digit + REMARKS + It tests whether wc is a letter or decimal digit. + RETURNS + TRUE or FLASE. + envhp(IN/OUT) + OCI environment handle to determine the character set . + wc(IN) + Wchar for testing. +*/ +boolean OCIWideCharIsAlnum(void *envhp, OCIWchar wc); + + +/* ----------------------- OCIWideCharIsAlpha -------------------------------*/ +/* + NAME + OCIWideCharIsAlpha - test whether wc is an alphabetic letter + REMARKS + It tests whether wc is an alphabetic letter + RETURNS + TRUE or FLASE. + envhp(IN/OUT) + OCI environment handle to determine the character set . + wc(IN) + Wchar for testing. +*/ +boolean OCIWideCharIsAlpha(void *envhp, OCIWchar wc); + + +/* --------------------- OCIWideCharIsCntrl ---------------------------------*/ +/* + NAME + OCIWideCharIsCntrl - test whether wc is a control character + REMARKS + It tests whether wc is a control character. + RETURNS + TRUE or FLASE. + envhp(IN/OUT) + OCI environment handle to determine the character set . + wc(IN) + Wchar for testing. +*/ +boolean OCIWideCharIsCntrl(void *envhp, OCIWchar wc); + + +/* ----------------------- OCIWideCharIsDigit -------------------------------*/ +/* + NAME + OCIWideCharIsDigit - test whether wc is a decimal digit character + REMARKS + It tests whether wc is a decimal digit character. + RETURNS + TRUE or FLASE. + envhp(IN/OUT) + OCI environment handle to determine the character set . + wc(IN) + Wchar for testing. +*/ +boolean OCIWideCharIsDigit(void *envhp, OCIWchar wc); + + +/* ----------------------- OCIWideCharIsGraph -------------------------------*/ +/* + NAME + OCIWideCharIsGraph - test whether wc is a graph character + REMARKS + It tests whether wc is a graph character. A graph character is character + with a visible representation and normally includes alphabetic letter, + decimal digit, and punctuation. + RETURNS + TRUE or FLASE. + envhp(IN/OUT) + OCI environment handle to determine the character set . + wc(IN) + Wchar for testing. +*/ +boolean OCIWideCharIsGraph(void *envhp, OCIWchar wc); + + +/* ----------------------- OCIWideCharIsLower -------------------------------*/ +/* + NAME + OCIWideCharIsLower - test whether wc is a lowercase letter + REMARKS + It tests whether wc is a lowercase letter. + RETURNS + TRUE or FLASE. + envhp(IN/OUT) + OCI environment handle to determine the character set . + wc(IN) + Wchar for testing. +*/ +boolean OCIWideCharIsLower(void *envhp, OCIWchar wc); + + +/* ----------------------- OCIWideCharIsPrint -------------------------------*/ +/* + NAME + OCIWideCharIsPrint - test whether wc is a printable character + REMARKS + It tests whether wc is a printable character. + RETURNS + TRUE or FLASE. + envhp(IN/OUT) + OCI environment handle to determine the character set . + wc(IN) + Wchar for testing. +*/ +boolean OCIWideCharIsPrint(void *envhp, OCIWchar wc); + + +/* ----------------------- OCIWideCharIsPunct -------------------------------*/ +/* + NAME + OCIWideCharIsPunct - test whether wc is a punctuation character + REMARKS + It tests whether wc is a punctuation character. + RETURNS + TRUE or FLASE. + envhp(IN/OUT) + OCI environment handle to determine the character set . + wc(IN) + Wchar for testing. +*/ +boolean OCIWideCharIsPunct(void *envhp, OCIWchar wc); + + +/* ----------------------- OCIWideCharIsSpace -------------------------------*/ +/* + NAME + OCIWideCharIsSpace - test whether wc is a space character + REMARKS + It tests whether wc is a space character. A space character only causes + white space in displayed text(for example, space, tab, carriage return, + newline, vertical tab or form feed). + RETURNS + TRUE or FLASE. + envhp(IN/OUT) + OCI environment handle to determine the character set . + wc(IN) + Wchar for testing. +*/ +boolean OCIWideCharIsSpace(void *envhp, OCIWchar wc); + + +/* ----------------------- OCIWideCharIsUpper -------------------------------*/ +/* + NAME + OCIWideCharIsUpper - test whether wc is a uppercase letter + REMARKS + It tests whether wc is a uppercase letter. + RETURNS + TRUE or FLASE. + envhp(IN/OUT) + OCI environment handle to determine the character set . + wc(IN) + Wchar for testing. +*/ +boolean OCIWideCharIsUpper(void *envhp, OCIWchar wc); + + +/*----------------------- OCIWideCharIsXdigit -------------------------------*/ +/* + NAME + OCIWideCharIsXdigit - test whether wc is a hexadecimal digit + REMARKS + It tests whether wc is a hexadecimal digit ( 0-9, A-F, a-f ). + RETURNS + TRUE or FLASE. + envhp(IN/OUT) + OCI environment handle to determine the character set . + wc(IN) + Wchar for testing. +*/ +boolean OCIWideCharIsXdigit(void *envhp, OCIWchar wc); + + +/* --------------------- OCIWideCharIsSingleByte ----------------------------*/ +/* + NAME + OCIWideCharIsSingleByte - test whether wc is a single-byte character + REMARKS + It tests whether wc is a single-byte character when converted into + multi-byte. + RETURNS + TRUE or FLASE. + envhp(IN/OUT) + OCI environment handle to determine the character set . + wc(IN) + Wchar for testing. +*/ +boolean OCIWideCharIsSingleByte(void *envhp, OCIWchar wc); + + +/* ----------------------- OCIWideCharToLower -------------------------------*/ +/* + NAME + OCIWideCharToLower - Convert a wchar into the lowercase + REMARKS + If there is a lower-case character mapping for wc in the specified locale, + it will return the lower-case in wchar, else return wc itself. + RETURNS + A wchar + envhp(IN/OUT) + OCI environment handle to determine the character set . + wc(IN) + Wchar for lowercase mapping. +*/ +OCIWchar OCIWideCharToLower(void *envhp, OCIWchar wc); + + +/* ----------------------- OCIWideCharToUpper -------------------------------*/ +/* + NAME + OCIWideCharToUpper - Convert a wchar into the uppercase + REMARKS + If there is a upper-case character mapping for wc in the specified locale, + it will return the upper-case in wchar, else return wc itself. + RETURNS + A wchar + envhp(IN/OUT) + OCI environment handle to determine the character set . + wc(IN) + Wchar for uppercase mapping. +*/ +OCIWchar OCIWideCharToUpper(void *envhp, OCIWchar wc); + + +/* ----------------------- OCIWideCharStrcmp --------------------------------*/ +/* + NAME + OCIWideCharStrcmp - compare two null terminated wchar string + REMARKS + It compares two wchar string in binary ( based on wchar encoding value ), + linguistic, or case-insensitive. + RETURNS + 0, if wstr1 == wstr2. + Positive, if wstr1 > wstr2. + Negative, if wstr1 < wstr2. + envhp(IN/OUT) + OCI environment handle to determine the character set. + wstr1(IN) + Pointer to a null-terminated wchar string. + wstr2(IN) + Pointer to a null-terminated wchar string. + flag(IN) + It is used to decide the comparison method. It can be taken one of the + following values: + OCI_NLS_BINARY : for the binary comparison, this is default value. + OCI_NLS_LINGUISTIC : for linguistic comparison specified in the locale. + This flag can be ORed with OCI_NLS_CASE_INSENSITIVE for case-insensitive + comparison. +*/ +int OCIWideCharStrcmp(void *envhp, const OCIWchar *wstr1, + const OCIWchar *wstr2, int flag); + + +/* ----------------------- OCIWideCharStrncmp -------------------------------*/ +/* + NAME + OCIWideCharStrncmp - compare twe wchar string in length + REMARKS + This function is similar to OCIWideCharStrcmp(), except that at most len1 + characters from wstr1 and len2 characters from wstr1 are compared. The + null-terminator will be taken into the comparison. + RETURNS + 0, if wstr1 = wstr2 + Positive, if wstr1 > wstr2 + Negative, if wstr1 < wstr2 + envhp(IN/OUT) + OCI environment handle to determine the character set . + wstr1(IN) + Pointer to the first wchar string + len1(IN) + The length for the first string for comparison + wstr2(IN) + Pointer to the second wchar string + len2(IN) + The length for the second string for comparison. + flag(IN) + It is used to decide the comparison method. It can be taken one of the + following values: + OCI_NLS_BINARY : for the binary comparison, this is default value. + OCI_NLS_LINGUISTIC : for linguistic comparison specified in the locale. + This flag can be ORed with OCI_NLS_CASE_INSENSITIVE for case-insensitive + comparison. +*/ +int OCIWideCharStrncmp(void *envhp, const OCIWchar *wstr1, size_t len1, + const OCIWchar *wstr2, size_t len2, int flag); + + +/* ----------------------- OCIWideCharStrcat --------------------------------*/ +/* + NAME + OCIWideCharStrcat - concatenate two wchar strings + REMARKS + This function appends a copy of the wchar string pointed to by wsrcstr, + including the null-terminator to the end of wchar string pointed to by + wdststr. It returns the number of character in the result string not + including the ending null-terminator. + RETURNS + number of characters in the result string not including the ending + null-terminator. + envhp(IN/OUT) + OCI environment handle to determine the character set . + wdststr(IN/OUT) + Pointer to the destination wchar string for appending. + wsrcstr(IN) + Pointer to the source wchar string to append. +*/ +size_t OCIWideCharStrcat(void *envhp, OCIWchar *wdststr, + const OCIWchar *wsrcstr); + + +/* ----------------------- OCIWideCharStrchr --------------------------------*/ +/* + NAME + OCIWideCharStrchr - Search the first occurrence of wchar in a wchar string + REMARKS + This function searchs for the first occurrence of wc in the wchar string + pointed to by wstr. It returns a pointer to the whcar if successful, or + a null pointer. + RETURNS + wchar pointer if successful, otherwise a null pointer. + envhp(IN/OUT) + OCI environment handle to determine the character set . + wstr(IN) + Pointer to the wchar string to search + wc(IN) + Wchar to search for. +*/ +OCIWchar *OCIWideCharStrchr(void *envhp, const OCIWchar *wstr, + OCIWchar wc); + + +/* ----------------------- OCIWideCharStrcpy --------------------------------*/ +/* + NAME + OCIWideCharStrcpy - copy a wchar string + REMARKS + This function copies the wchar string pointed to by wsrcstr, including the + null-terminator, into the array pointed to by wdststr. It returns the + number of character copied not including the ending null-terminator. + RETURNS + number of characters copied not including the ending null-terminator. + envhp(IN/OUT) + OCI environment handle to determine the character set . + wdststr(OUT) + Pointer to the destination wchar buffer. + wsrcstr(IN) + Pointer to the source wchar string. +*/ +size_t OCIWideCharStrcpy(void *envhp, OCIWchar *wdststr, + const OCIWchar *wsrcstr); + + +/* ----------------------- OCIWideCharStrlen --------------------------------*/ +/* + NAME + OCIWideCharStrlen - Return number of character in a wchar string + REMARKS + This function computes the number of characters in the wchar string + pointed to by wstr, not including the null-terminator, and returns + this number. + RETURNS + number of characters not including ending null-terminator. + envhp(IN/OUT) + OCI environment handle to determine the character set . + wstr(IN) + Pointer to the source wchar string. +*/ +size_t OCIWideCharStrlen(void *envhp, const OCIWchar *wstr); + + +/* ----------------------- OCIWideCharStrncat -------------------------------*/ +/* + NAME + OCIWideCharStrncat - Concatenate wchar string in length + REMARKS + This function is similar to OCIWideCharStrcat(), except that at most n + characters from wsrcstr are appended to wdststr. Note that the + null-terminator in wsrcstr will stop appending. wdststr will be + null-terminated.. + RETURNS + Number of characters in the result string not including the ending + null-terminator. + envhp(IN/OUT) + OCI environment handle to determine the character set . + wdststr(IN/OUT) + Pointer to the destination wchar string for appending. + wsrcstr(IN) + Pointer to the source wchar string to append. + n(IN) + Number of characters from wsrcstr to append. +*/ +size_t OCIWideCharStrncat(void *envhp, OCIWchar *wdststr, + const OCIWchar *wsrcstr, size_t n); + + +/* ----------------------- OCIWideCharStrncpy -------------------------------*/ +/* + NAME + OCIWideCharStrncpy - Copy wchar string in length + REMARKS + This function is similar to OCIWideCharStrcpy(), except that at most n + characters are copied from the array pointed to by wsrcstr to the array + pointed to by wdststr. Note that the null-terminator in wdststr will + stop coping and result string will be null-terminated. + RETURNS + number of characters copied not including the ending null-terminator. + envhp(IN/OUT) + OCI environment handle to determine the character set . + wdststr(OUT) + Pointer to the destination wchar buffer. + wsrcstr(IN) + Pointer to the source wchar string. + n(IN) + Number of characters from wsrcstr to copy. +*/ +size_t OCIWideCharStrncpy(void *envhp, OCIWchar *wdststr, + const OCIWchar *wsrcstr, size_t n); + + +/* ----------------------- OCIWideCharStrrchr -------------------------------*/ +/* + NAME + OCIWideCharStrrchr - search the last occurrence of a wchar in wchar string + REMARKS + This function searchs for the last occurrence of wc in the wchar string + pointed to by wstr. It returns a pointer to the whcar if successful, or + a null pointer. + RETURNS + wchar pointer if successful, otherwise a null pointer. + envhp(IN/OUT) + OCI environment handle to determine the character set . + wstr(IN) + Pointer to the wchar string to search + wc(IN) + Wchar to search for. +*/ +OCIWchar *OCIWideCharStrrchr(void *envhp, const OCIWchar *wstr, + OCIWchar wc); + + +/* --------------------- OCIWideCharStrCaseConversion -----------------------*/ +/* + NAME + OCIWideCharStrCaseConversion - convert a wchar string into lowercase or + uppercase + REMARKS + This function convert the wide char string pointed to by wsrcstr into the + uppercase or lowercase specified by flag and copies the result into the + array pointed to by wdststr. The result string will be null-terminated. + RETURNS + number of characters for result string not including null-terminator. + envhp(IN/OUT) + OCI environment handle. + wdststr(OUT) + Pointer to destination array. + wsrcstr(IN) + Pointer to source string. + flag(IN) + Specify the case to convert: + OCI_NLS_UPPERCASE : convert to uppercase. + OCI_NLS_LOWERCASE: convert to lowercase. + This flag can be ORed with OCI_NLS_LINGUISTIC to specify that the + linguistic setting in the locale will be used for case conversion. +*/ +size_t OCIWideCharStrCaseConversion(void *envhp, OCIWchar *wdststr, + const OCIWchar *wsrcstr, ub4 flag); + + +/*---------------------- OCIWideCharDisplayLength ---------------------------*/ +/* + NAME + OCIWideCharDisplayLength - Calculate the display length for a wchar + REMARKS + This function determines the number of column positions required for wc + in display. It returns number of column positions, or 0 if wc is + null-terminator. + RETURNS + Number of display positions. + envhp(IN/OUT) + OCI environment handle to determine the character set . + wc(IN) + Wchar character. +*/ +size_t OCIWideCharDisplayLength(void *envhp, OCIWchar wc ); + + +/*---------------------- OCIWideCharMultiByteLength -------------------------*/ +/* + NAME + OCIWideCharMultiByteLength - Determine byte size in multi-byte encoding + REMARKS + This function determines the number of byte required for wc in multi-byte + encoding. It returns number of bytes in multi-byte for wc. + RETURNS + Number of bytes. + envhp(IN/OUT) + OCI environment handle to determine the character set . + wc(IN) + Wchar character. +*/ +size_t OCIWideCharMultiByteLength(void *envhp, OCIWchar wc); + + +/* ----------------------- OCIMultiByteStrcmp -------------------------------*/ +/* + NAME + OCIMultiByteStrcmp - Compare two multi-byte strings + REMARKS + It compares two multi-byte strings in binary ( based on encoding value ), + linguistic, or case-insensitive. + RETURNS + 0, if str1 == str2. + Positive, if str1 > str2. + Negative, if str1 < str2. + envhp(IN/OUT) + OCI environment handle to determine the character set. + str1(IN) + Pointer to a null-terminated string. + str2(IN) + Pointer to a null-terminated string. + flag(IN) + It is used to decide the comparison method. It can be taken one of the + following values: + OCI_NLS_BINARY: for the binary comparison, this is default value. + OCI_NLS_LINGUISTIC: for linguistic comparison specified in the locale. + This flag can be ORed with OCI_NLS_CASE_INSENSITIVE for case-insensitive + comparison. +*/ +int OCIMultiByteStrcmp(void *envhp, const OraText *str1, + const OraText *str2, int flag); + + +/*----------------------- OCIMultiByteStrncmp -------------------------------*/ +/* + NAME + OCIMultiByteStrncmp - compare two strings in length + REMARKS + This function is similar to OCIMultiBytestrcmp(), except that at most + len1 bytes from str1 and len2 bytes from str2 are compared. The + null-terminator will be taken into the comparison. + RETURNS + 0, if str1 = str2 + Positive, if str1 > str2 + Negative, if str1 < str2 + envhp(IN/OUT) + OCI environment handle to determine the character set. + str1(IN) + Pointer to the first string + len1(IN) + The length for the first string for comparison + str2(IN) + Pointer to the second string + len2(IN) + The length for the second string for comparison. + flag(IN) + It is used to decide the comparison method. It can be taken one of the + following values: + OCI_NLS_BINARY: for the binary comparison, this is default value. + OCI_NLS_LINGUISTIC: for linguistic comparison specified in the locale. + This flag can be ORed with OCI_NLS_CASE_INSENSITIVE for case-insensitive + comparison. +*/ +int OCIMultiByteStrncmp(void *envhp, const OraText *str1, size_t len1, + OraText *str2, size_t len2, int flag); + + +/*----------------------- OCIMultiByteStrcat --------------------------------*/ +/* + NAME + OCIMultiByteStrcat - concatenate multibyte strings + REMARKS + This function appends a copy of the multi-byte string pointed to by + srcstr, including the null-terminator to the end of string pointed to by + dststr. It returns the number of bytes in the result string not including + the ending null-terminator. + RETURNS + number of bytes in the result string not including the ending + null-terminator. + envhp(IN/OUT) + Pointer to OCI environment handle + dststr(IN/OUT) + Pointer to the destination multi-byte string for appending. + srcstr(IN) + Pointer to the source string to append. +*/ +size_t OCIMultiByteStrcat(void *envhp, OraText *dststr, + const OraText *srcstr); + + +/*------------------------- OCIMultiByteStrcpy ------------------------------*/ +/* + NAME + OCIMultiByteStrcpy - copy multibyte string + REMARKS + This function copies the multi-byte string pointed to by srcstr, + including the null-terminator, into the array pointed to by dststr. It + returns the number of bytes copied not including the ending + null-terminator. + RETURNS + number of bytes copied not including the ending null-terminator. + envhp(IN/OUT) + Pointer to the OCI environment handle. + srcstr(OUT) + Pointer to the destination buffer. + dststr(IN) + Pointer to the source multi-byte string. +*/ +size_t OCIMultiByteStrcpy(void *envhp, OraText *dststr, + const OraText *srcstr); + + +/*----------------------- OCIMultiByteStrlen --------------------------------*/ +/* + NAME + OCIMultiByteStrlen - Calculate multibyte string length + REMARKS + This function computes the number of bytes in the multi-byte string + pointed to by str, not including the null-terminator, and returns this + number. + RETURNS + number of bytes not including ending null-terminator. + str(IN) + Pointer to the source multi-byte string. +*/ +size_t OCIMultiByteStrlen(void *envhp, const OraText *str); + + +/*----------------------- OCIMultiByteStrncat -------------------------------*/ +/* + NAME + OCIMultiByteStrncat - concatenate string in length + REMARKS + This function is similar to OCIMultiBytestrcat(), except that at most n + bytes from srcstr are appended to dststr. Note that the null-terminator in + srcstr will stop appending and the function will append as many character + as possible within n bytes. dststr will be null-terminated. + RETURNS + Number of bytes in the result string not including the ending + null-terminator. + envhp(IN/OUT) + Pointer to OCI environment handle. + srcstr(IN/OUT) + Pointer to the destination multi-byte string for appending. + dststr(IN) + Pointer to the source multi-byte string to append. + n(IN) + Number of bytes from srcstr to append. +*/ +size_t OCIMultiByteStrncat(void *envhp, OraText *dststr, + const OraText *srcstr, size_t n); + + +/*----------------------- OCIMultiByteStrncpy -------------------------------*/ +/* + NAME + OCIMultiByteStrncpy - copy multibyte string in length + REMARKS + This function is similar to OCIMultiBytestrcpy(), except that at most n + bytes are copied from the array pointed to by srcstr to the array pointed + to by dststr. Note that the null-terminator in srcstr will stop coping and + the function will copy as many character as possible within n bytes. The + result string will be null-terminated. + RETURNS + number of bytes copied not including the ending null-terminator. + envhp(IN/OUT) + Pointer to a OCI environment handle. + dststr(IN) + Pointer to the source multi-byte string. + srcstr(OUT) + Pointer to the destination buffer. + n(IN) + Number of bytes from srcstr to copy. +*/ +size_t OCIMultiByteStrncpy(void *envhp, OraText *dststr, + const OraText *srcstr, size_t n); + + +/*----------------------- OCIMultiByteStrnDisplayLength ---------------------*/ +/* + NAME + OCIMultiByteStrnDisplayLength - calculate the display length for a + multibyt string + REMARKS + This function returns the number of display positions occupied by the + complete characters within the range of n bytes. + RETURNS + number of display positions. + envhp(IN/OUT) + OCI environment handle. + str(IN) + Pointer to a multi-byte string. + n(IN) + Number of bytes to examine. +*/ +size_t OCIMultiByteStrnDisplayLength(void *envhp, const OraText *str1, + size_t n); + + +/*---------------------- OCIMultiByteStrCaseConversion ---------------------*/ +/* + NAME + OCIMultiByteStrCaseConversion + REMARKS + This function convert the multi-byte string pointed to by srcstr into the + uppercase or lowercase specified by flag and copies the result into the + array pointed to by dststr. The result string will be null-terminated. + RETURNS + number of bytes for result string not including null-terminator. + envhp(IN/OUT) + OCI environment handle. + dststr(OUT) + Pointer to destination array. + srcstr(IN) + Pointer to source string. + flag(IN) + Specify the case to convert: + OCI_NLS_UPPERCASE: convert to uppercase. + OCI_NLS_LOWERCASE: convert to lowercase. + This flag can be ORed with OCI_NLS_LINGUISTIC to specify that the + linguistic setting in the locale will be used for case conversion. +*/ +size_t OCIMultiByteStrCaseConversion(void *envhp, OraText *dststr, + const OraText *srcstr, ub4 flag); + + +/*------------------------- OCICharSetToUnicode -----------------------------*/ +/* + NAME + OCICharSetToUnicode - convert multibyte string into Unicode as UCS2 + REMARKS + This function converts a multi-byte string pointed to by src to Unicode + into the array pointed to by dst. The conversion will stop when it reach + to the source limitation or destination limitation. + The function will return number of characters converted into Unicode. + If dstlen is zero, it will just return the number of characters for the + result without real conversion. + RETURNS + OCI_SUCCESS, OCI_INVALID_HANDLE or OCI_ERROR + envhp(IN/OUT) + Pointer to an OCI environment handle + dst(OUT) + Pointer to a destination buffer + dstlen(IN) + Size of destination buffer in character + src(IN) + Pointer to multi-byte source string. + srclen(IN) + Size of source string in bytes. + rsize(OUT) + Number of characters converted. + If it is a NULL pointer, nothing to return. +*/ +sword OCICharSetToUnicode(void *envhp, ub2 *dst, size_t dstlen, + const OraText *src, size_t srclen, size_t *rsize); + + +/*------------------------- OCIUnicodeToCharSet -----------------------------*/ +/* + NAME + OCIUnicodeToCharSet - convert Unicode into multibyte + REMARKS + This function converts a Unicode string pointed to by src to multi-byte + into the array pointed to by dst. The conversion will stop when it reach + to the source limitation or destination limitation. The function will + return number of bytes converted into multi-byte. If dstlen is zero, it + will just return the number of bytes for the result without real + conversion. If a Unicode character is not convertible for the character + set specified in OCI environment handle, a replacement character will be + used for it. In this case, OCICharSetConversionIsReplacementUsed() will + return ture. + RETURNS + OCI_SUCCESS, OCI_INVALID_HANDLE or OCI_ERROR + envhp(IN/OUT) + Pointer to an OCI environment handle. + dst(OUT) + Pointer to a destination buffer. + dstlen(IN) + Size of destination buffer in byte. + src(IN) + Pointer to a Unicode string. + srclen(IN) + Size of source string in characters. + rsize(OUT) + Number of bytes converted. + If it is a NULL pointer, nothing to return. +*/ +sword OCIUnicodeToCharSet(void *envhp, OraText *dst, size_t dstlen, + const ub2 *src, size_t srclen, size_t *rsize); + +/*----------------------- OCINlsCharSetConvert ------------------------------*/ +/* + NAME + OCINlsCharSetConvert - convert between any two character set. + REMARKS + This function converts a string pointed to by src in the character set + specified with srcid to the array pointed to by dst in the character set + specified with dstid. The conversion will stop when it reaches the source + limitation or destination limitation. The function will return the number + of bytes converted into the destination buffer. Even though either source + or destination character set id is OCI_UTF16ID, given and return data + length will be represented with the byte length as this function is + intended for generic purpose. Note the conversion will not stop at null + data. + To get character set id from name, OCINlsCharSetNameToId can be used. + To check if derived data in the destination buffer contains any + replacement character resulting from conversion failure, + OCICharSetConversionIsReplacementUsed can be used to get the status. + Data alignment should be guaranteed by a caller. For example, UTF-16 data + should be aligned to ub2 type. + + RETURNS + OCI_SUCCESS or OCI_ERROR. + errhp(IN/OUT) + OCI error handle. If there is an error, it is recorded in errhp and this + function returns a NULL pointer. Diagnostic information can be obtained + by calling OCIErrorGet(). + dstid(IN) + Character set id for the destination buffer. + dstp(OUT) + Pointer to the destination buffer. + dstlen(IN) + The maximum byte size of destination buffer. + srcid(IN) + Character set id for the source buffer. + srcp(IN) + Pointer to the source buffer. + srclen(IN) + The length byte size of source buffer. + rsize(OUT) + The number of characters converted. If it is a NULL pointer, nothing to + return. +*/ +sword OCINlsCharSetConvert(void *envhp, OCIError *errhp, + ub2 dstid, void *dstp, size_t dstlen, + ub2 srcid, const void *srcp, size_t srclen, + size_t *rsize); + + +/* ------------------- OCICharsetConversionIsReplacementUsed ----------------*/ +/* + NAME + OCICharsetConversionIsReplacementUsed - chech if replacement is used in + conversion + REMARKS + This function indicates whether or not the replacement character was used + for nonconvertible characters in character set conversion in last invoke + of OCICharsetUcs2ToMb(). + RETURNS + TRUE is the replacement character was used in last OCICharsetUcs2ToMb() + invoking, else FALSE. + envhp(IN/OUT) + OCI environment handle. This should be the first handle passed to + OCICharsetUcs2ToMb(). +*/ +boolean OCICharSetConversionIsReplacementUsed(void *envhp); + +/*------------------- OCINlsEnvironmentVariableGet -----------------*/ +/* + NAME + OCINlsEnvironmentVariableGet - get a value of NLS environment variable. + + DESCRIPTION + This function retrieves a value of NLS environment variable to the buffer + pointed to by val. Data type is determined by the parameter specified by + item. Either numeric data or string data can be retrieved. + + RETURNS + OCI_SUCCESS or OCI_ERROR. + + PARAMETERS + valp(OUT) - + Pointer to the buffer. + size(IN) - + Size of the buffer. This argument is only applicable to string data type, + but not to numerical data, in such case, it is ignored. + item(IN) - + NLS item value, which can be one of following values: + OCI_NLS_CHARSET_ID - NLS_LANG character set id in ub2 data type. + OCI_NLS_NCHARSET_ID - NLS_NCHAR character set id in ub2 data type. + charset(IN) - + Character set id for retrieved string data. If it is 0, NLS_LANG will be + used. OCI_UTF16ID is a valid id. In case of numeric data, this argument + is ignored. + rsize(OUT) - + Size of return value. + + NOTE + This functions is mainly used for retrieving character set id from either + NLS_LANG or NLS_NCHAR environment variables. If NLS_LANG is not set, + the default character set id is returned. + For future extension, the buffer is capable for storing other data types. +*/ +sword OCINlsEnvironmentVariableGet(void *valp, size_t size, ub2 item, + ub2 charset, size_t *rsize); + + +/*------------------------- OCIMessageOpen ----------------------------------*/ +/* + NAME + OCIMessageOpen - open a locale message file + REMARKS + This function opens a message handle for facility of product in a language + pointed to by envhp. It first try to open the message file corresponding + to envhp for the facility. If it successes, it will use that file to + initialize a message handle, else it will use the default message file + which is for American language for the facility. The function return a + pointer pointed to a message handle into msghp parameter. + RETURNS + OCI_SUCCESS, OCI_INVALID_HANDLE or OCI_ERROR + envhp(IN/OUT) + A pointer to OCI environment handle for message language. + errhp(IN/OUT) + The OCI error handle. If there is an error, it is record in errhp and this + function returns a NULL pointer. Diagnostic information can be obtained by + calling OCIErrorGet(). + msghp(OUT) + a message handle for return + product(IN) + A pointer to a product name. Product name is used to locate the directory + for message in a system dependent way. For example, in Solaris, the + directory of message files for the product `rdbms' is + `${ORACLE_HOME}/rdbms'. + facility(IN) + A pointer to a facility name in the product. It is used to construct a + message file name. A message file name follows the conversion with + facility as prefix. For example, the message file name for facility + `img' in American language will be `imgus.msb' where `us' is the + abbreviation of American language and `msb' as message binary file + extension. + dur(IN) + Duration for memory allocation for the return message handle. It can be + the following values: + OCI_DURATION_CALL + OCI_DURATION_STATEMENT + OCI_DURATION_SESSION + OCI_DURATION_TRANSACTION + For the detail description, please refer to Memory Related Service + Interfaces section. +*/ +sword OCIMessageOpen(void *envhp, OCIError *errhp, OCIMsg **msghp, + const OraText *product, const OraText *facility, + OCIDuration dur); + + +/*------------------------- OCIMessageGet -----------------------------------*/ +/* + NAME + OCIMessageGet - get a locale message from a message handle + REMARKS + This function will get message with message number identified by msgno and + if buflen is not zero, the function will copy the message into the buffer + pointed to by msgbuf. If buflen is zero, the message will be copied into + a message buffer inside the message handle pointed to by msgh. For both + cases. it will return the pointer to the null-terminated message string. + If it cannot get the message required, it will return a NULL pointer. + RETURNS + A pointer to a null-terminated message string on success, otherwise a NULL + pointer. + msgh(IN/OUT) + Pointer to a message handle which was previously opened by + OCIMessageOpen(). + msgno(IN) + The message number for getting message. + msgbuf(OUT) + Pointer to a destination buffer to the message retrieved. If buflen is + zero, it can be NULL pointer. + buflen(IN) + The size of the above destination buffer. +*/ +OraText *OCIMessageGet(OCIMsg *msgh, ub4 msgno, OraText *msgbuf, + size_t buflen); + +/*------------------------- OCIMessageClose ---------------------------------*/ +/* + NAME + OCIMessageClose - close a message handle + REMARKS + This function closes a message handle pointed to by msgh and frees any + memory associated with this handle. + RETURNS + OCI_SUCCESS, OCI_INVALID_HANDLE or OCI_ERROR + envhp(IN/OUT) + A pointer to OCI environment handle for message language. + errhp(IN/OUT) + The OCI error handle. If there is an error, it is record in errhp and this + function returns a NULL pointer. Diagnostic information can be obtained by + calling OCIErrorGet(). + msghp(IN/OUT) + A pointer to a message handle which was previously opened by + OCIMessageOpen(). +*/ +sword OCIMessageClose(void *envhp, OCIError *errhp, OCIMsg *msghp); + +/*--------------- End of Extensions to NLS cartridge service ----------------*/ + + +/*----------------- Extensions to OCI Thread interface ---------------------*/ +/***************************************************************************** + DESCRIPTION +****************************************************************************** +1 Threads Interface + +The OCIThread package provides a number of commonly used threading +primitives for use by Oracle customers. It offers a portable interface to +threading capabilities native to various platforms. It does not implement +threading on platforms which do not have native threading capability. + +OCIThread does not provide a portable implementation of multithreaded +facilities. It only serves as a set of portable covers for native +multithreaded facilities. Therefore, platforms that do not have native +support for multi-threading will only be able to support a limited +implementation of OCIThread. As a result, products that rely on all of +OCIThread's functionality will not port to all platforms. Products that must +port to all platforms must use only a subset of OCIThread's functionality. +This issue is discussed further in later sections of this document. + +The OCIThread API is split into four main parts. Each part is described +briefly here. The following subsections describe each in greater detail. + + 1. Initialization and Termination Calls + + These calls deal with the initialization and termination of OCIThread. + Initialization of OCIThread initializes the OCIThread context which is + a member of the OCI environment or session handle. This context is + required for other OCIThread calls. + + 2. Passive Threading Primitives + + The passive threading primitives include primitives to manipulate mutual + exclusion (mutex) locks, thread ID's, and thread-specific data keys. + + The reason that these primitives are described as 'passive' is that while + their specifications allow for the existence of multiple threads, they do + not require it. This means that it is possible for these primitives to + be implemented according to specification in both single-threaded and + multi-threaded environments. + + As a result, OCIThread clients that use only these primitives will not + require the existence of multiple threads in order to work correctly, + i.e., they will be able to work in single-threaded environments without + branching code. + + 3. Active Threading Primitives + + Active threading primitives include primitives dealing with the creation, + termination, and other manipulation of threads. + + The reason that these primitives are described as 'active' is that they + can only be used in true multi-threaded environments. Their + specifications explicitly require that it be possible to have multiple + threads. If you need to determine at runtime whether or not you are in a + multi-threaded environment, call OCIThreadIsMulti() before calling an + OCIThread active primitive. + + +1.1 Initialization & Termination +================================== + +The types and functions described in this section are associated with the +initialization and termination of the OCIThread package. OCIThread must +be properly initialized before any of its functionality can be used. +OCIThread's process initialization function, 'OCIThreadProcessInit()', +must be called with care; see below. + +The observed behavior of the initialization and termination functions is the +same regardless of whether OCIThread is in single-threaded or multi-threaded +environment. It is OK to call the initialization functions from both generic +and operating system specific (OSD) code. + +1.1.1 Types + + OCIThreadContext - OCIThread Context + ------------------------------------- + + Most calls to OCIThread functions take the OCI environment or session + handle as a parameter. The OCIThread context is part of the OCI + environment or session handle and it must be initialized by calling + 'OCIThreadInit()'. Termination of the OCIThread context occurs by calling + 'OCIThreadTerm()'. + + The OCIThread context is a private data structure. Clients must NEVER + attempt to examine the contents of the context. + +1.1.2 OCIThreadProcessInit + + OCIThreadProcessInit - OCIThread Process INITialization + -------------------------------------------------------- + + Description + + This function should be called to perform OCIThread process + initialization. + + Prototype + + void OCIThreadProcessInit(); + + Returns + + Nothing. + + Notes + + Whether or not this function needs to be called depends on how OCI + Thread is going to be used. + + * In a single-threaded application, calling this function is optional. + If it is called at all, the first call to it must occur before calls + to any other OCIThread functions. Subsequent calls can be made + without restriction; they will not have any effect. + + * In a multi-threaded application, this function MUST be called. The + first call to it MUST occur 'strictly before' any other OCIThread + calls; i.e., no other calls to OCIThread functions (including other + calls to this one) can be concurrent with the first call. + Subsequent calls to this function can be made without restriction; + they will not have any effect. + + +1.1.3 OCIThreadInit + + OCIThreadInit - OCIThread INITialize + ------------------------------------- + + Description + + This initializes OCIThread context. + + Prototype + + sword OCIThreadInit(void *hndl, OCIError *err); + + hndl(IN/OUT): The OCI environment or session handle. + + err(IN/OUT): The OCI error handle. If there is an error and OCI_ERROR + is returned, the error is recorded in err and diagnostic + information can be obtained by calling OCIErrorGet(). + + Returns + + OCI_SUCCESS, OCI_ERROR or OCI_INVALID_HANDLE. + + Notes + + It is illegal for OCIThread clients to try an examine the memory + pointed to by the returned pointer. + + It is safe to make concurrent calls to 'OCIThreadInit()'. Unlike + 'OCIThreadProcessInit()', there is no need to have a first call + that occurs before all the others. + + The first time 'OCIThreadInit()' is called, it initilaizes the OCI + Thread context. It also saves a pointer to the context in some system + dependent manner. Subsequent calls to 'OCIThreadInit()' will return + the same context. + + Each call to 'OCIThreadInit()' must eventually be matched by a call to + 'OCIThreadTerm()'. + + OCIThreadTerm - OCIThread TERMinate + ------------------------------------ + + Description + + This should be called to release the OCIThread context. It should be + called exactly once for each call made to 'OCIThreadInit()'. + + Prototype + + sword OCIThreadTerm(void *hndl, OCIError *err); + + hndl(IN/OUT): The OCI environment or session handle. + + err(IN/OUT): The OCI error handle. If there is an error and OCI_ERROR + is returned, the error is recorded in err and diagnostic + information can be obtained by calling OCIErrorGet(). + + Returns + + OCI_SUCCESS, OCI_ERROR or OCI_INVALID_HANDLE. + + Notes + + It is safe to make concurrent calls to 'OCIThreadTerm()'. + + 'OCIThreadTerm()' will not do anything until it has been called as + many times as 'OCIThreadInit()' has been called. When that happens, + it terminates the OCIThread layer and frees the memory allocated for + the context. Once this happens, the context should not be re-used. + It will be necessary to obtain a new one by calling 'OCIThreadInit()'. + + + OCIThreadIsMulti - OCIThread Is Multi-Threaded? + ------------------------------------------------ + + Description + + This tells the caller whether the application is running in a + multi-threaded environment or a single-threaded environment. + + Prototype + boolean OCIThreadIsMulti(void); + + Returns + + TRUE if the environment is multi-threaded; + FALSE if the environment is single-threaded. + + +1.2 Passive Threading Primitives +================================== + +1.2.1 Types + +The passive threading primitives deal with the manipulation of mutex, +thread ID's, and thread-specific data. Since the specifications of these +primitives do not require the existence of multiple threads, they can be +used both on multithreaded and single-threaded platforms. + +1.2.1.1 OCIThreadMutex - OCIThread Mutual Exclusion Lock +----------------------------------------------------------- + + The type 'OCIThreadMutex' is used to represent a mutual exclusion lock + (mutex). A mutex is typically used for one of two purposes: (i) to + ensure that only one thread accesses a given set of data at a time, or + (ii) to ensure that only one thread executes a given critical section of + code at a time. + + Mutexes pointer can be declared as parts of client structures or as + stand-alone variables. Before they can be used, they must be initialized + using 'OCIThreadMutexInit()'. Once they are no longer needed, they must be + destroyed using 'OCIThreadMutexDestroy()'. A mutex pointer must NOT be + used after it is destroyed. + + A thread can acquire a mutex by using either 'OCIThreadMutexAcquire()' or + 'OCIThreadMutexTry()'. They both ensure that only one thread at a time is + allowed to hold a given mutex. A thread that holds a mutex can release it + by calling 'OCIThreadMutexRelease()'. + + +1.2.1.2 OCIThreadKey - OCIThread Key for Thread-Specific Data +---------------------------------------------------------------- + + A key can be thought of as a process-wide variable that has a + thread-specific value. What this means is that all the threads in a + process can use any given key. However, each thread can examine or modify + that key independently of the other threads. The value that a thread sees + when it examines the key will always be the same as the value that it last + set for the key. It will not see any values set for the key by the other + threads. + + The type of the value held by a key is a 'void *' generic pointer. + + Keys can be created using 'OCIThreadKeyInit()'. When a key is created, its + value is initialized to 'NULL' for all threads. + + A thread can set a key's value using 'OCIThreadKeySet()'. A thread can + get a key's value using 'OCIThreadKeyGet()'. + + The OCIThread key functions will save and retrieve data SPECIFIC TO THE + THREAD. When clients maintain a pool of threads and assign the threads to + different tasks, it *may not* be appropriate for a task to use OCIThread + key functions to save data associated with it. Here is a scenario of how + things can fail: A thread is assigned to execute the initialization of a + task. During the initialization, the task stored some data related to it + in the thread using OCIThread key functions. After the initialization, + the thread is returned back to the threads pool. Later, the threads pool + manager assigned another thread to perform some operations on the task, + and the task needs to retrieve those data it stored earlier in + initialization. Since the task is running in another thread, it will not + be able to retrieve the same data back! Applications that use thread + pools should be aware of this and be cautious when using OCIThread key + functions. + + +1.2.1.3 OCIThreadKeyDestFunc - OCIThread Key Destructor Function Type +------------------------------------------------------------------------ + + This is the type of a pointer to a key's destructor routine. Keys can be + associated with a destructor routine when they are created (see + 'OCIThreadKeyInit()'). + + A key's destructor routine will be called whenever a thread that has a + non-NULL value for the key terminates. + + The destructor routine returns nothing and takes one parameter. The + parameter will be the value that was set for key when the thread + terminated. + + The destructor routine is guaranteed to be called on a thread's value + in the key after the termination of the thread and before process + termination. No more precise guarantee can be made about the timing + of the destructor routine call; thus no code in the process may assume + any post-condition of the destructor routine. In particular, the + destructor is not guaranteed to execute before a join call on the + terminated thread returns. + + +1.2.1.4 OCIThreadId - OCIThread Thread ID +-------------------------------------------- + + Type 'OCIThreadId' is the type that will be used to identify a thread. + At any given time, no two threads will ever have the same 'OCIThreadId'. + However, 'OCIThreadId' values can be recycled; i.e., once a thread dies, + a new thread may be created that has the same 'OCIThreadId' as the one + that died. In particular, the thread ID must uniquely identify a thread + T within a process, and it must be consistent and valid in all threads U + of the process for which it can be guaranteed that T is running + concurrently with U. The thread ID for a thread T must be retrievable + within thread T. This will be done via OCIThreadIdGet(). + + The 'OCIThreadId' type supports the concept of a NULL thread ID: the NULL + thread ID will never be the same as the ID of an actual thread. + + + +1.2.2 Function prototypes for passive primitives +-------------------------------------------------- + +1.2.2.1 Mutex functions +------------------------- + + OCIThreadMutexInit - OCIThread MuteX Initialize + ----------------------------------------------- + + Description + + This allocate and initializes a mutex. All mutexes must be + initialized prior to use. + + Prototype + + sword OCIThreadMutexInit(void *hndl, OCIError *err, + OCIThreadMutex **mutex); + + hndl(IN/OUT): The OCI environment or session handle. + + err(IN/OUT): The OCI error handle. If there is an error and OCI_ERROR + is returned, the error is recorded in err and diagnostic + information can be obtained by calling OCIErrorGet(). + + mutex(OUT): The mutex to initialize. + + Returns + + OCI_SUCCESS, OCI_ERROR or OCI_INVALID_HANDLE. + + Notes + + Multiple threads must not initialize the same mutex simultaneously. + Also, a mutex must not be reinitialized until it has been destroyed (see + 'OCIThreadMutexDestroy()'). + + OCIThreadMutexDestroy - OCIThread MuteX Destroy + ----------------------------------------------- + + Description + + This destroys and deallocate a mutex. Each mutex must be destroyed + once it is no longer needed. + + Prototype + + sword OCIThreadMutexDestroy(void *hndl, OCIError *err, + OCIThreadMutex **mutex); + + hndl(IN/OUT): The OCI environment or session handle. + + err(IN/OUT): The OCI error handle. If there is an error and OCI_ERROR + is returned, the error is recorded in err and diagnostic + information can be obtained by calling OCIErrorGet(). + + mutex(IN/OUT): The mutex to destroy. + + Returns + + OCI_SUCCESS, OCI_ERROR or OCI_INVALID_HANDLE. + + Notes + + It is not legal to destroy a mutex that is uninitialized or is currently + held by a thread. The destruction of a mutex must not occur concurrently + with any other operations on the mutex. A mutex must not be used after + it has been destroyed. + + + OCIThreadMutexAcquire - OCIThread MuteX Acquire + ----------------------------------------------- + + Description + + This acquires a mutex for the thread in which it is called. If the mutex + is held by another thread, the calling thread is blocked until it can + acquire the mutex. + + Prototype + + sword OCIThreadMutexAcquire(void *hndl, OCIError *err, + OCIThreadMutex *mutex); + + hndl(IN/OUT): The OCI environment or session handle. + + err(IN/OUT): The OCI error handle. If there is an error, it is + recorded in err and this function returns OCI_ERROR. + Diagnostic information can be obtained by calling + OCIErrorGet(). + + mutex(IN/OUT): The mutex to acquire. + + Returns + + OCI_SUCCESS, OCI_ERROR or OCI_INVALID_HANDLE. + + Notes + + It is illegal to attempt to acquire an uninitialized mutex. + + This function's behavior is undefined if it is used by a thread to + acquire a mutex that is already held by that thread. + + + + OCIThreadMutexRelease - OCIThread MuteX Release + ----------------------------------------------- + + Description + + This releases a mutex. If there are any threads blocked on the mutex, + one of them will acquire it and become unblocked. + + Prototype + + sword OCIThreadMutexRelease(void *hndl, OCIError *err, + OCIThreadMutex *mutex); + + hndl(IN/OUT): The OCI environment or session handle. + + err(IN/OUT): The OCI error handle. If there is an error and OCI_ERROR + is returned, the error is recorded in err and diagnostic + information can be obtained by calling OCIErrorGet(). + + mutex(IN/OUT): The mutex to release. + + Returns + + OCI_SUCCESS, OCI_ERROR or OCI_INVALID_HANDLE. + + Notes + + It is illegal to attempt to release an uninitialized mutex. It is also + illegal for a thread to release a mutex that it does not hold. + + + OCIThreadKeyInit - OCIThread KeY Initialize + ------------------------------------------- + + Description + + This creates a key. Each call to this routine allocate and generates + a new key that is distinct from all other keys. + + Prototype + + sword OCIThreadKeyInit(void *hndl, OCIError *err, OCIThreadKey **key, + OCIThreadKeyDestFunc destFn); + + hndl(IN/OUT): The OCI environment or session handle. + + err(IN/OUT): The OCI error handle. If there is an error and OCI_ERROR + is returned, the error is recorded in err and diagnostic + information can be obtained by calling OCIErrorGet(). + + key(OUT): The 'OCIThreadKey' in which to create the new key. + + destFn(IN): The destructor for the key. NULL is permitted. + + Returns + + OCI_SUCCESS, OCI_ERROR or OCI_INVALID_HANDLE. + + Notes + + Once this function executes successfully, a pointer to an allocated and + initialized key is return. That key can be used with 'OCIThreadKeyGet()' + and 'OCIThreadKeySet()'. The initial value of the key will be 'NULL' for + all threads. + + It is illegal for this function to be called more than once to create the + same key (i.e., to be called more than once with the same value for the + 'key' parameter). + + If the 'destFn' parameter is not NULL, the routine pointed to by 'destFn' + will be called whenever a thread that has a non-NULL value for the key + terminates. The routine will be called with one parameter. The + parameter will be the key's value for the thread at the time at which the + thread terminated. + If the key does not need a destructor function, pass NULL for 'destFn'. + + + OCIThreadKeyDestroy - OCIThread KeY DESTROY + ------------------------------------------- + + Description + + Destroy and deallocate the key pointed to by 'key'. + + Prototype + + sword OCIThreadKeyDestroy(void *hndl, OCIError *err, + OCIThreadKey **key); + + hndl(IN/OUT): The OCI environment or session handle. + + err(IN/OUT): The OCI error handle. If there is an error and OCI_ERROR + is returned, the error is recorded in err and diagnostic + information can be obtained by calling OCIErrorGet(). + + key(IN/OUT): The 'OCIThreadKey' in which to destroy the key. + + Returns + + OCI_SUCCESS, OCI_ERROR or OCI_INVALID_HANDLE. + + Notes + + This is different from the destructor function callback passed to the + key create routine. This new destroy function 'OCIThreadKeyDestroy' is + used to terminate any resources OCI THREAD acquired when it created + 'key'. [The 'OCIThreadKeyDestFunc' callback type is a key VALUE + destructor; it does in no way operate on the key itself.] + + This must be called once the user has finished using the key. Not + calling the key destroy function may result in memory leaks. + + + + +1.2.2.2 Thread Key operations +------------------------------- + + OCIThreadKeyGet - OCIThread KeY Get value + ----------------------------------------- + + Description + + This gets the calling thread's current value for a key. + + Prototype + + sword OCIThreadKeyGet(void *hndl, OCIError *err, OCIThreadKey *key, + void **pValue); + + hndl(IN/OUT): The OCI environment or session handle. + + err(IN/OUT): The OCI error handle. If there is an error and OCI_ERROR + is returned, the error is recorded in err and diagnostic + information can be obtained by calling OCIErrorGet(). + + key(IN): The key. + + pValue(IN/OUT): The location in which to place the thread-specific + key value. + + Returns + + OCI_SUCCESS, OCI_ERROR or OCI_INVALID_HANDLE. + + Notes + + It is illegal to use this function on a key that has not been created + using 'OCIThreadKeyInit()'. + + If the calling thread has not yet assigned a value to the key, 'NULL' is + placed in the location pointed to by 'pValue'. + + + OCIThreadKeySet - OCIThread KeY Set value + ----------------------------------------- + + Description + + This sets the calling thread's value for a key. + + Prototype + + sword OCIThreadKeySet(void *hndl, OCIError *err, OCIThreadKey *key, + void *value); + + hndl(IN/OUT): The OCI environment or session handle. + + err(IN/OUT): The OCI error handle. If there is an error and OCI_ERROR + is returned, the error is recorded in err and diagnostic + information can be obtained by calling OCIErrorGet(). + + key(IN/OUT): The key. + + value(IN): The thread-specific value to set in the key. + + Returns + + OCI_SUCCESS, OCI_ERROR or OCI_INVALID_HANDLE. + + Notes + + It is illegal to use this function on a key that has not been created + using 'OCIThreadKeyInit()'. + +1.2.2.3 Thread Id +-------------------- + + OCIThreadIdInit - OCIThread Thread Id INITialize + -------------------------------------------------- + + Description + + Allocate and initialize the thread id 'tid'. + + Prototype + + sword OCIThreadIdInit(void *hndl, OCIError *err, OCIThreadId **tid); + + hndl(IN/OUT): The OCI environment or session handle. + + err(IN/OUT): The OCI error handle. If there is an error and OCI_ERROR + is returned, the error is recorded in err and diagnostic + information can be obtained by calling OCIErrorGet(). + + tid (OUT): Pointer to the thread ID to initialize. + + Returns + + OCI_SUCCESS, OCI_ERROR or OCI_INVALID_HANDLE. + + + OCIThreadIdDestroy - OCIThread Thread Id DESTROY + -------------------------------------------------- + + Description + + Destroy and deallocate the thread id 'tid'. + + Prototype + + sword OCIThreadIdDestroy(void *hndl, OCIError *err, OCIThreadId **tid); + + hndl(IN/OUT): The OCI environment or session handle. + + err(IN/OUT): The OCI error handle. If there is an error and OCI_ERROR + is returned, the error is recorded in err and diagnostic + information can be obtained by calling OCIErrorGet(). + + tid(IN/OUT): Pointer to the thread ID to destroy. + + Returns + + OCI_SUCCESS, OCI_ERROR or OCI_INVALID_HANDLE. + + Note + + 'tid' should be initialized by OCIThreadIdInit(). + + + OCIThreadIdSet - OCIThread Thread Id Set + ----------------------------------------- + + Description + + This sets one 'OCIThreadId' to another. + + Prototype + + sword OCIThreadIdSet(void *hndl, OCIError *err, + OCIThreadId *tidDest, + OCIThreadId *tidSrc); + + hndl(IN/OUT): The OCI environment or session handle. + + err(IN/OUT): The OCI error handle. If there is an error and OCI_ERROR + is returned, the error is recorded in err and diagnostic + information can be obtained by calling OCIErrorGet(). + + tidDest(OUT): This should point to the location of the 'OCIThreadId' + to be set to. + + tidSrc(IN): This should point to the 'OCIThreadId' to set from. + + Returns + + OCI_SUCCESS, OCI_ERROR or OCI_INVALID_HANDLE. + + Notes + + 'tid' should be initialized by OCIThreadIdInit(). + + + OCIThreadIdSetNull - OCIThread Thread Id Set Null + --------------------------------------------------------- + + Description + + This sets the NULL thread ID to a given 'OCIThreadId'. + + Prototype + + sword OCIThreadIdSetNull(void *hndl, OCIError *err, + OCIThreadId *tid); + + hndl(IN/OUT): The OCI environment or session handle. + + err(IN/OUT): The OCI error handle. If there is an error, it is + recorded in err and this function returns OCI_ERROR. + Diagnostic information can be obtained by calling + OCIErrorGet(). + + tid(OUT): This should point to the 'OCIThreadId' in which to put + the NULL thread ID. + + Returns + + OCI_SUCCESS, OCI_ERROR or OCI_INVALID_HANDLE. + + Notes + + 'tid' should be initialized by OCIThreadIdInit(). + + + OCIThreadIdGet - OCIThread Thread Id Get + ------------------------------------------ + + Description + + This retrieves the 'OCIThreadId' of the thread in which it is called. + + Prototype + + sword OCIThreadIdGet(void *hndl, OCIError *err, + OCIThreadId *tid); + + hndl(IN/OUT): The OCI environment or session handle. + + err(IN/OUT): The OCI error handle. If there is an error and OCI_ERROR + is returned, the error is recorded in err and diagnostic + information can be obtained by calling OCIErrorGet(). + + tid(OUT): This should point to the location in which to place the + ID of the calling thread. + + Returns + + OCI_SUCCESS, OCI_ERROR or OCI_INVALID_HANDLE. + + Notes + + 'tid' should be initialized by OCIThreadIdInit(). + + When OCIThread is used in a single-threaded environment, + OCIThreadIdGet() will always place the same value in the location + pointed to by 'tid'. The exact value itself is not important. The + important thing is that it is not the same as the NULL thread ID and + that it is always the same value. + + + OCIThreadIdSame - OCIThread Thread Ids Same? + ---------------------------------------------- + + Description + + This determines whether or not two 'OCIThreadId's represent the same + thread. + + Prototype + + sword OCIThreadIdSame(void *hndl, OCIError *err, + OCIThreadId *tid1, OCIThreadId *tid2, + boolean *result); + + hndl(IN/OUT): The OCI environment or session handle. + + err(IN/OUT): The OCI error handle. If there is an error and OCI_ERROR + is returned, the error is recorded in err and diagnostic + information can be obtained by calling OCIErrorGet(). + + tid1(IN): Pointer to the first 'OCIThreadId'. + + tid2(IN): Pointer to the second 'OCIThreadId'. + + result(IN/OUT): Pointer to the result. + + Returns + + OCI_SUCCESS, OCI_ERROR or OCI_INVALID_HANDLE. + + Notes + + If 'tid1' and 'tid2' represent the same thread, 'result' is set to TRUE. + Otherwise, 'result' is set to FALSE. + + 'result' is set to TRUE if both 'tid1' and 'tid2' are the NULL thread ID. + + 'ti1d' and 'tid2' should be initialized by OCIThreadIdInit(). + + + OCIThreadIdNull - OCIThread Thread Id NULL? + --------------------------------------------- + + Description + + This determines whether or not a given 'OCIThreadId' is the NULL thread + ID. + + Prototype + + sword OCIThreadIdNull(void *hndl, OCIError *err, + OCIThreadId *tid, + boolean *result); + + hndl(IN/OUT): The OCI environment or session handle. + + err(IN/OUT): The OCI error handle. If there is an error and OCI_ERROR + is returned, the error is recorded in err and diagnostic + information can be obtained by calling OCIErrorGet(). + + tid(IN): Pointer to the 'OCIThreadId' to check. + + result(IN/OUT): Pointer to the result. + + Returns + + OCI_SUCCESS, OCI_ERROR or OCI_INVALID_HANDLE. + + Notes + + If 'tid' is the NULL thread ID, 'result' is set to TRUE. Otherwise, + 'result' is set to FALSE. + + 'tid' should be initialized by OCIThreadIdInit(). + + +1.3 Active Threading Primitives +================================= + +The active threading primitives deal with the manipulation of actual +threads. Because the specifications of most of these primitives require +that it be possible to have multiple threads, they work correctly only in +the enabled OCIThread; In the disabled OCIThread, they always return +failure. The exception is OCIThreadHandleGet(); it may be called in a +single-threaded environment, in which case it will have no effect. + +Active primitives should only be called by code running in a multi-threaded +environment. You can call OCIThreadIsMulti() to determine whether the +environment is multi-threaded or single-threaded. + + +1.3.1 Types +-------------- + +1.3.1.1 OCIThreadHandle - OCIThread Thread Handle +------------------------------------------------------ + + Type 'OCIThreadHandle' is used to manipulate a thread in the active + primitives: OCIThreadJoin()and OCIThreadClose(). A thread handle opened by + OCIThreadCreate() must be closed in a matching call to + OCIThreadClose(). A thread handle is invalid after the call to + OCIThreadClose(). + + The distinction between a thread ID and a thread handle in OCIThread usage + follows the distinction between the thread ID and the thread handle on + Windows NT. On many platforms, the underlying native types are the same. + + +1.3.2 Functions +------------------ + + OCIThreadHndInit - OCIThread HaNDle Initialize + ---------------------------------------------- + + Description + + Allocate and initialize the thread handle. + + Prototype + + sword OCIThreadHndInit(void *hndl, OCIError *err, + OCIThreadHandle **thnd); + + hndl(IN/OUT): The OCI environment or session handle. + + err(IN/OUT): The OCI error handle. If there is an error and OCI_ERROR + is returned, the error is recorded in err and diagnostic + information can be obtained by calling OCIErrorGet(). + + thnd(OUT): The address of pointer to the thread handle to initialize. + + Returns + + OCI_SUCCESS, OCI_ERROR or OCI_INVALID_HANDLE. + + + OCIThreadHndDestroy - OCIThread HaNDle Destroy + ---------------------------------------------- + + Description + + Destroy and deallocate the thread handle. + + Prototype + + sword OCIThreadHndDestroy(void *hndl, OCIError *err, + OCIThreadHandle **thnd); + + hndl(IN/OUT): The OCI environment or session handle. + + err(IN/OUT): The OCI error handle. If there is an error and OCI_ERROR + is returned, the error is recorded in err and diagnostic + information can be obtained by calling OCIErrorGet(). + + thnd(IN/OUT): The address of pointer to the thread handle to destroy. + + Returns + + OCI_SUCCESS, OCI_ERROR or OCI_INVALID_HANDLE. + + Notes + + 'thnd' should be initialized by OCIThreadHndInit(). + + + OCIThreadCreate - OCIThread Thread Create + ----------------------------------------- + + Description + + This creates a new thread. + + Prototype + + sword OCIThreadCreate(void *hndl, OCIError *err, + void (*start)(void *), void *arg, + OCIThreadId *tid, OCIThreadHandle *tHnd); + + hndl(IN/OUT): The OCI environment or session handle. + + err(IN/OUT): The OCI error handle. If there is an error and OCI_ERROR + is returned, the error is recorded in err and diagnostic + information can be obtained by calling OCIErrorGet(). + + start(IN): The function in which the new thread should begin + execution. + + arg(IN): The argument to give the function pointed to by 'start'. + + tid(IN/OUT): If not NULL, gets the ID for the new thread. + + tHnd(IN/OUT): If not NULL, gets the handle for the new thread. + + Returns + + OCI_SUCCESS, OCI_ERROR or OCI_INVALID_HANDLE. + + Notes + + The new thread will start by executing a call to the function pointed + to by 'start' with the argument given by 'arg'. When that function + returns, the new thread will terminate. The function should not + return a value and should accept one parameter, a 'void *'. + + The call to OCIThreadCreate() must be matched by a call to + OCIThreadClose() if and only if tHnd is non-NULL. + + If tHnd is NULL, a thread ID placed in *tid will not be valid in the + calling thread because the timing of the spawned thread's termination + is unknown. + + 'tid' should be initialized by OCIThreadIdInit(). + + 'thnd' should be initialized by OCIThreadHndInit(). + + + + OCIThreadJoin - OCIThread Thread Join + ------------------------------------- + + Description + + This function allows the calling thread to 'join' with another thread. + It blocks the caller until the specified thread terminates. + + Prototype + + sword OCIThreadJoin(void *hndl, OCIError *err, OCIThreadHandle *tHnd); + + hndl(IN/OUT): The OCI environment or session handle. + + err(IN/OUT): The OCI error handle. If there is an error and OCI_ERROR + is returned, the error is recorded in err and diagnostic + information can be obtained by calling OCIErrorGet(). + + tHnd(IN): The 'OCIThreadHandle' of the thread to join with. + + Returns + + OCI_SUCCESS, OCI_ERROR or OCI_INVALID_HANDLE. + + Notes + + 'thnd' should be initialized by OCIThreadHndInit(). + + The result of multiple threads all trying to join with the same thread is + undefined. + + + OCIThreadClose - OCIThread Thread Close + --------------------------------------- + + Description + + This function should be called to close a thread handle. + + Prototype + + sword OCIThreadClose(void *hndl, OCIError *err, OCIThreadHandle *tHnd); + + hndl(IN/OUT): The OCI environment or session handle. + + err(IN/OUT): The OCI error handle. If there is an error and OCI_ERROR + is returned, the error is recorded in err and diagnostic + information can be obtained by calling OCIErrorGet(). + + tHnd(IN/OUT): The OCIThread thread handle to close. + + Returns + + OCI_SUCCESS, OCI_ERROR or OCI_INVALID_HANDLE. + + Notes + + 'thnd' should be initialized by OCIThreadHndInit(). + + Both thread handle and the thread ID that was returned by the same call + to OCIThreadCreate() are invalid after the call to OCIThreadClose(). + + + + OCIThreadHandleGet - OCIThread Thread Get Handle + ------------------------------------------------ + + Description + + Retrieve the 'OCIThreadHandle' of the thread in which it is called. + + Prototype + + sword OCIThreadHandleGet(void *hndl, OCIError *err, + OCIThreadHandle *tHnd); + + hndl(IN/OUT): The OCI environment or session handle. + + err(IN/OUT): The OCI error handle. If there is an error and OCI_ERROR + is returned, the error is recorded in err and diagnostic + information can be obtained by calling OCIErrorGet(). + + tHnd(IN/OUT): If not NULL, the location to place the thread + handle for the thread. + + Returns + + OCI_SUCCESS, OCI_ERROR or OCI_INVALID_HANDLE. + + Notes + + 'thnd' should be initialized by OCIThreadHndInit(). + + The thread handle 'tHnd' retrieved by this function must be closed + with OCIThreadClose() and destroyed by OCIThreadHndDestroy() after it + is used. + + + + +1.4 Using OCIThread +===================== + +This section summarizes some of the more important details relating to the use +of OCIThread. + + * Process initialization + + OCIThread only requires that the process initialization function + ('OCIThreadProcessInit()') be called when OCIThread is being used in a + multi-threaded application. Failing to call 'OCIThreadProcessInit()' in + a single-threaded application is not an error. + + * OCIThread initialization + + Separate calls to 'OCIThreadInit()' will all return the same OCIThread + context. + + Also, remember that each call to 'OCIThreadInit()' must eventually be + matched by a call to 'OCIThreadTerm()'. + + * Active vs. Passive Threading primitives + + OCIThread client code written without using any active primitives can be + compiled and used without change on both single-threaded and + multi-threaded platforms. + + OCIThread client code written using active primitives will only work + correctly on multi-threaded platforms. In order to write a version of the + same application to run on single-threaded platform, it is necessary to + branch the your code, whether by branching versions of the source file or + by branching at runtime with the OCIThreadIsMulti() call. + +******************************************************************************/ + +/***************************************************************************** + ACTUAL PROTOTYPE DECLARATIONS +******************************************************************************/ + +void OCIThreadProcessInit(); + +sword OCIThreadInit(void *hndl, OCIError *err); + +sword OCIThreadTerm(void *hndl, OCIError *err); + +boolean OCIThreadIsMulti(); + +sword OCIThreadMutexInit(void *hndl, OCIError *err, + OCIThreadMutex **mutex); + +sword OCIThreadMutexDestroy(void *hndl, OCIError *err, + OCIThreadMutex **mutex); + +sword OCIThreadMutexAcquire(void *hndl, OCIError *err, + OCIThreadMutex *mutex); + +sword OCIThreadMutexRelease(void *hndl, OCIError *err, + OCIThreadMutex *mutex); + +sword OCIThreadKeyInit(void *hndl, OCIError *err, OCIThreadKey **key, + OCIThreadKeyDestFunc destFn); + +sword OCIThreadKeyDestroy(void *hndl, OCIError *err, + OCIThreadKey **key); + +sword OCIThreadKeyGet(void *hndl, OCIError *err, OCIThreadKey *key, + void **pValue); + +sword OCIThreadKeySet(void *hndl, OCIError *err, OCIThreadKey *key, + void *value); + +sword OCIThreadIdInit(void *hndl, OCIError *err, OCIThreadId **tid); + +sword OCIThreadIdDestroy(void *hndl, OCIError *err, OCIThreadId **tid); + +sword OCIThreadIdSet(void *hndl, OCIError *err, + OCIThreadId *tidDest, OCIThreadId *tidSrc); + +sword OCIThreadIdSetNull(void *hndl, OCIError *err, OCIThreadId *tid); + +sword OCIThreadIdGet(void *hndl, OCIError *err, OCIThreadId *tid); + +sword OCIThreadIdSame(void *hndl, OCIError *err, + OCIThreadId *tid1, OCIThreadId *tid2, + boolean *result); + +sword OCIThreadIdNull(void *hndl, OCIError *err, + OCIThreadId *tid, boolean *result); + +sword OCIThreadHndInit(void *hndl, OCIError *err, OCIThreadHandle **thnd); + +sword OCIThreadHndDestroy(void *hndl, OCIError *err, OCIThreadHandle **thnd); + +sword OCIThreadCreate(void *hndl, OCIError *err, + void (*start)(void *), void *arg, + OCIThreadId *tid, OCIThreadHandle *tHnd); + +sword OCIThreadJoin(void *hndl, OCIError *err, OCIThreadHandle *tHnd); + +sword OCIThreadClose(void *hndl, OCIError *err, OCIThreadHandle *tHnd); + +sword OCIThreadHandleGet(void *hndl, OCIError *err, OCIThreadHandle *tHnd); +/*----------------- End OCI Thread interface Extensions ---------------------*/ + +/*------------------ Begin OCI Row Callback Interfaces ----------------------*/ + +typedef sword (*OCIBindRowCallback)(void *ctx); +typedef sword (*OCIFetchRowCallback)(void *ctx); + +/*------------------ Begin OCI Row Callback Interfaces ----------------------*/ + +/*--------------- Begin OCI Client Notification Interfaces ------------------*/ + +typedef ub4 (*OCISubscriptionNotify)(void *ctx, OCISubscription *subscrhp, + void *pay, ub4 payl, + void *desc, ub4 mode); + +sword OCISubscriptionRegister(OCISvcCtx *svchp, OCISubscription **subscrhpp, + ub2 count, OCIError *errhp, ub4 mode); + + +sword OCISubscriptionPost(OCISvcCtx *svchp, OCISubscription **subscrhpp, + ub2 count, OCIError *errhp, ub4 mode); + +sword OCISubscriptionUnRegister(OCISvcCtx *svchp, OCISubscription *subscrhp, + OCIError *errhp, ub4 mode); + +sword OCISubscriptionDisable(OCISubscription *subscrhp, + OCIError *errhp, ub4 mode); + +sword OCISubscriptionEnable(OCISubscription *subscrhp, + OCIError *errhp, ub4 mode); + +/*------------------- End OCI Publish/Subscribe Interfaces ------------------*/ + +/*----------------- Extensions to Datetime interfaces -----------------------*/ +/*--------------------- Actual Prototypes -----------------------------------*/ +sword OCIDateTimeGetTime(void *hndl, OCIError *err, OCIDateTime *datetime, + ub1 *hr, ub1 *mm, ub1 *ss, ub4 *fsec); + +sword OCIDateTimeGetDate(void *hndl, OCIError *err, const OCIDateTime *date, + sb2 *yr, ub1 *mnth, ub1 *dy ); + +sword OCIDateTimeGetTimeZoneOffset(void *hndl,OCIError *err, + const OCIDateTime *datetime, + sb1 *hr,sb1 *mm); + +sword OCIDateTimeConstruct(void *hndl,OCIError *err,OCIDateTime *datetime, + sb2 yr,ub1 mnth,ub1 dy,ub1 hr,ub1 mm,ub1 ss,ub4 fsec, + OraText *timezone,size_t timezone_length); + +sword OCIDateTimeSysTimeStamp(void *hndl, OCIError *err, + OCIDateTime *sys_date ); + +sword OCIDateTimeAssign(void *hndl, OCIError *err, const OCIDateTime *from, + OCIDateTime *to); + +sword OCIDateTimeToText(void *hndl, OCIError *err, const OCIDateTime *date, + const OraText *fmt, ub1 fmt_length, ub1 fsprec, + const OraText *lang_name, size_t lang_length, + ub4 *buf_size, OraText *buf ); + +sword OCIDateTimeFromText(void *hndl, OCIError *err, const OraText *date_str, + size_t dstr_length, const OraText *fmt, ub1 fmt_length, + const OraText *lang_name, size_t lang_length, OCIDateTime *date ); + +sword OCIDateTimeCompare(void *hndl, OCIError *err, const OCIDateTime *date1, + const OCIDateTime *date2, sword *result ); + +sword OCIDateTimeCheck(void *hndl, OCIError *err, const OCIDateTime *date, + ub4 *valid ); + +sword OCIDateTimeConvert(void *hndl, OCIError *err, OCIDateTime *indate, + OCIDateTime *outdate); + +sword OCIDateTimeSubtract(void *hndl, OCIError *err, OCIDateTime *indate1, + OCIDateTime *indate2, OCIInterval *inter); + +sword OCIDateTimeIntervalAdd(void *hndl, OCIError *err, OCIDateTime *datetime, + OCIInterval *inter, OCIDateTime *outdatetime); + +sword OCIDateTimeIntervalSub(void *hndl, OCIError *err, OCIDateTime *datetime, + OCIInterval *inter, OCIDateTime *outdatetime); + +sword OCIIntervalSubtract(void *hndl, OCIError *err, OCIInterval *minuend, + OCIInterval *subtrahend, OCIInterval *result ); + +sword OCIIntervalAdd(void *hndl, OCIError *err, OCIInterval *addend1, + OCIInterval *addend2, OCIInterval *result ); + +sword OCIIntervalMultiply(void *hndl, OCIError *err, const OCIInterval *inter, + OCINumber *nfactor, OCIInterval *result ); + +sword OCIIntervalDivide(void *hndl, OCIError *err, OCIInterval *dividend, + OCINumber *divisor, OCIInterval *result ); + +sword OCIIntervalCompare(void *hndl, OCIError *err, OCIInterval *inter1, + OCIInterval *inter2, sword *result ); + +sword OCIIntervalFromNumber(void *hndl, OCIError *err, OCIInterval *inter, + OCINumber *number); + +sword OCIIntervalFromText( void *hndl, OCIError *err, const OraText *inpstr, + size_t str_len, OCIInterval *result ); + +sword OCIIntervalToText( void *hndl, OCIError *err, const OCIInterval *inter, + ub1 lfprec, ub1 fsprec, + OraText *buffer, size_t buflen, size_t *resultlen ); + +sword OCIIntervalToNumber(void *hndl, OCIError *err,const OCIInterval *inter, + OCINumber *number); + +sword OCIIntervalCheck(void *hndl, OCIError *err, const OCIInterval *interval, + ub4 *valid ); + +sword OCIIntervalAssign(void *hndl, OCIError *err, const OCIInterval *ininter, + OCIInterval *outinter ); + +sword OCIIntervalSetYearMonth(void *hndl, OCIError *err, sb4 yr, sb4 mnth, + OCIInterval *result ); + +sword OCIIntervalGetYearMonth(void *hndl, OCIError *err, sb4 *yr, sb4 *mnth, + const OCIInterval *result ); + +sword OCIIntervalSetDaySecond(void *hndl, OCIError *err, sb4 dy, sb4 hr, + sb4 mm, sb4 ss, sb4 fsec, OCIInterval *result ); + +sword OCIIntervalGetDaySecond(void *hndl, OCIError *err, sb4 *dy, sb4 *hr, + sb4 *mm, sb4 *ss, sb4 *fsec, const OCIInterval *result ); + +sword OCIDateTimeToArray(void *hndl, OCIError *err, + const OCIDateTime *datetime, const OCIInterval *reftz, + ub1 *outarray, ub4 *len, ub1 fsprec); + +sword OCIDateTimeFromArray(void *hndl, OCIError *err, ub1 *inarray, ub4 len, + ub1 type, OCIDateTime *datetime, + const OCIInterval *reftz, ub1 fsprec); + +sword OCIDateTimeGetTimeZoneName(void *hndl, OCIError *err, + const OCIDateTime *datetime, + ub1 *buf, ub4 *buflen); + +sword OCIIntervalFromTZ(void *hndl, OCIError *err, const oratext *inpstring, + size_t str_len, OCIInterval *result); + +/*----------------- End Datetime interface Extensions -----------------------*/ + +/*----------------- Connection Pooling prototypes ---------------------------*/ +sword OCIConnectionPoolCreate(OCIEnv *envhp, OCIError *errhp, OCICPool *poolhp, + OraText **poolName, sb4 *poolNameLen, + const OraText *dblink, sb4 dblinkLen, + ub4 connMin, ub4 connMax, ub4 connIncr, + const OraText *poolUserName, sb4 poolUserLen, + const OraText *poolPassword, sb4 poolPassLen, + ub4 mode); + +sword OCIConnectionPoolDestroy(OCICPool *poolhp, + OCIError *errhp, ub4 mode); + +/*----------------- End Connection Pooling prototypes -----------------------*/ + +/*-------------------- Session Pooling prototypes ---------------------------*/ + +sword OCISessionPoolCreate (OCIEnv *envhp, OCIError *errhp, OCISPool *spoolhp, + OraText **poolName, ub4 *poolNameLen, + const OraText *connStr, ub4 connStrLen, + ub4 sessMin, ub4 sessMax, ub4 sessIncr, + OraText *userid, ub4 useridLen, + OraText *password, ub4 passwordLen, + ub4 mode); + +sword OCISessionPoolDestroy (OCISPool *spoolhp, + OCIError *errhp, + ub4 mode); + +sword OCISessionGet (OCIEnv *envhp, OCIError *errhp, OCISvcCtx **svchp, + OCIAuthInfo *authhp, + OraText *poolName, ub4 poolName_len, + const OraText *tagInfo, ub4 tagInfo_len, + OraText **retTagInfo, ub4 *retTagInfo_len, + boolean *found, ub4 mode); + +sword OCISessionRelease (OCISvcCtx *svchp, OCIError *errhp, + OraText *tag, ub4 tag_len, + ub4 mode); + +/*-------------------- End Session Pooling prototypes -----------------------*/ + +/* --------------------- OCI Application Context --------------------------*/ + + +sword OCIAppCtxSet(void * sesshndl, void *nsptr, ub4 nsptrlen, + void *attrptr, ub4 attrptrlen, + void *valueptr, ub4 valueptrlen, + OCIError *errhp, ub4 mode); + +sword OCIAppCtxClearAll(void *sesshndl, void *nsptr, ub4 nsptrlen, + OCIError *errhp, ub4 mode); + +/*-------------------------------- OCIMemStats ------------------------------*/ +sword OCIMemStats(void *hndlp, OCIError *errhp, OCIEnv **envhp, + ub4 mode, ub4 mode1, oratext *tabname); + +/*-------------------------------- OCIPing ----------------------------------*/ +sword OCIPing (OCISvcCtx *svchp, OCIError *errhp, ub4 mode); + +/*----------------- Kerberos Authentication prototypes ----------------------*/ + +sword OCIKerbAttrSet(OCISession *trgthndlp, ub4 cred_use, ub1 *ftgt_ticket, + ub4 ticket_len, ub1 *session_key, ub4 skey_len, + ub2 ftgt_keytype, ub4 ftgt_ticket_flags, + sb4 ftgt_auth_time, sb4 ftgt_start_time, + sb4 ftgt_end_time, sb4 ftgt_renew_time, + oratext *ftgt_client_principal, + ub4 ftgt_client_principal_len, oratext *ftgt_client_realm, + ub4 ftgt_client_realm_len, OCIError *errhp); + +/*------------------- End Kerberos Authentication prototypes ----------------*/ + +/*------------------- Database Startup/Shutdown prototypes ------------------*/ + +sword OCIDBStartup (OCISvcCtx *svchp, + OCIError *errhp, + OCIAdmin *admhp, + ub4 mode, + ub4 flags); + +sword OCIDBShutdown(OCISvcCtx *svchp, + OCIError *errhp, + OCIAdmin *admhp, + ub4 mode); + +/*------------------ End Database Startup/Shutdown prototypes ---------------*/ + +/*----------------------- OCIClientVersion ------------------------------*/ +void OCIClientVersion(sword *major_version, + sword *minor_version, + sword *update_num, + sword *patch_num, + sword *port_update_num); +/*----------------------- End OCIClientVersion --------------------------*/ + +/*----------------------- HA Event prototypes ------------------------------*/ + +sword OCIInitEventHandle(OCIError *errhp, + OCIEvent *event, + text *str, + ub4 size); + +/*----------------------- End HA Event prototypes --------------------------*/ + +/*--------------------------------------------------------------------------- + PRIVATE FUNCTIONS + ---------------------------------------------------------------------------*/ + + /* the following functions are depracated and should not be used */ +#ifdef NEVER +sword OCIStmtBindByPos (OCIStmt *stmtp, OCIBind *bindp, OCIError *errhp, + ub4 position, void *valuep, sb4 value_sz, + ub2 dty, void *indp, ub2 *alenp, ub2 *rcodep, + ub4 maxarr_len, ub4 *curelep, ub4 mode); + + +sword OCIStmtBindByName (OCIStmt *stmtp, OCIBind *bindp, OCIError *errhp, + const OraText *placeholder, sb4 placeh_len, void *valuep, + sb4 value_sz, ub2 dty, void *indp, ub2 *alenp, + ub2 *rcodep, ub4 maxarr_len, ub4 *curelep, ub4 mode); + +sword ocidefn (OCIStmt *stmtp, OCIDefine *defnp, OCIError *errhp, + ub4 position, void *valuep, sb4 value_sz, ub2 dty, + void *indp, ub2 *rlenp, ub2 *rcodep, ub4 mode); +#endif /* NEVER */ + +#endif /* OCIAP_ORACLE */ diff --git a/OCI/include/ociapr.h b/OCI/include/ociapr.h new file mode 100644 index 0000000..2f25c52 --- /dev/null +++ b/OCI/include/ociapr.h @@ -0,0 +1,155 @@ +/* Copyright (c) 1991, 2005, Oracle. All rights reserved. */ +/* + NAME + ociapr.h + MODIFIED (MM/DD/YY) + mbastawa 09/16/05 - dbhygiene + dmukhin 06/29/05 - ANSI prototypes; miscellaneous cleanup + dsaha 05/19/00 - Fix lint + sgollapu 05/19/98 - Change text to OraText + dchatter 11/10/95 - add ognfd() - get native fd + lchidamb 04/06/95 - drop maxdsz from obindps/odefinps + slari 04/07/95 - add opinit + dchatter 03/08/95 - osetpi and ogetpi + lchidamb 12/09/94 - add obindps() and odefinps() + dchatter 03/06/95 - merge changes from branch 1.1.720.2 + dchatter 11/14/94 - merge changes from branch 1.1.720.1 + dchatter 02/08/95 - olog call; drop onblon + dchatter 10/31/94 - new functions for non-blocking oci + rkooi2 11/27/92 - Changing datatypes to agree with ocidef.h + rkooi2 10/26/92 - More portability mods + rkooi2 10/18/92 - Changed to agree with oci.c + sjain 03/16/92 - Creation +*/ +/* + * Declare the OCI functions. + * Prototype information is included. + * Use this header for ANSI C compilers. + */ + +#ifndef OCIAPR +#define OCIAPR + +#ifndef ORATYPES +#include +#endif + +#ifndef OCIDFN +#include +#endif + +/* + * Oci BIND (Piecewise or with Skips) + */ +sword obindps(struct cda_def *cursor, ub1 opcode, OraText *sqlvar, + sb4 sqlvl, ub1 *pvctx, sb4 progvl, + sword ftype, sword scale, + sb2 *indp, ub2 *alen, ub2 *arcode, + sb4 pv_skip, sb4 ind_skip, sb4 alen_skip, sb4 rc_skip, + ub4 maxsiz, ub4 *cursiz, + OraText *fmt, sb4 fmtl, sword fmtt); +sword obreak(struct cda_def *lda); +sword ocan (struct cda_def *cursor); +sword oclose(struct cda_def *cursor); +sword ocof (struct cda_def *lda); +sword ocom (struct cda_def *lda); +sword ocon (struct cda_def *lda); + + +/* + * Oci DEFINe (Piecewise or with Skips) + */ +sword odefinps(struct cda_def *cursor, ub1 opcode, sword pos,ub1 *bufctx, + sb4 bufl, sword ftype, sword scale, + sb2 *indp, OraText *fmt, sb4 fmtl, sword fmtt, + ub2 *rlen, ub2 *rcode, + sb4 pv_skip, sb4 ind_skip, sb4 alen_skip, sb4 rc_skip); +sword odessp(struct cda_def *cursor, OraText *objnam, size_t onlen, + ub1 *rsv1, size_t rsv1ln, ub1 *rsv2, size_t rsv2ln, + ub2 *ovrld, ub2 *pos, ub2 *level, OraText **argnam, + ub2 *arnlen, ub2 *dtype, ub1 *defsup, ub1* mode, + ub4 *dtsiz, sb2 *prec, sb2 *scale, ub1 *radix, + ub4 *spare, ub4 *arrsiz); +sword odescr(struct cda_def *cursor, sword pos, sb4 *dbsize, + sb2 *dbtype, sb1 *cbuf, sb4 *cbufl, sb4 *dsize, + sb2 *prec, sb2 *scale, sb2 *nullok); +sword oerhms (struct cda_def *lda, sb2 rcode, OraText *buf, + sword bufsiz); +sword oermsg (sb2 rcode, OraText *buf); +sword oexec (struct cda_def *cursor); +sword oexfet (struct cda_def *cursor, ub4 nrows, + sword cancel, sword exact); +sword oexn (struct cda_def *cursor, sword iters, sword rowoff); +sword ofen (struct cda_def *cursor, sword nrows); +sword ofetch (struct cda_def *cursor); +sword oflng (struct cda_def *cursor, sword pos, ub1 *buf, + sb4 bufl, sword dtype, ub4 *retl, sb4 offset); +sword ogetpi (struct cda_def *cursor, ub1 *piecep, void **ctxpp, + ub4 *iterp, ub4 *indexp); +sword oopt (struct cda_def *cursor, sword rbopt, sword waitopt); +sword opinit (ub4 mode); +sword olog (struct cda_def *lda, ub1* hda, + OraText *uid, sword uidl, + OraText *pswd, sword pswdl, + OraText *conn, sword connl, + ub4 mode); +sword ologof (struct cda_def *lda); +sword oopen (struct cda_def *cursor, struct cda_def *lda, + OraText *dbn, sword dbnl, sword arsize, + OraText *uid, sword uidl); +sword oparse (struct cda_def *cursor, OraText *sqlstm, sb4 sqllen, + sword defflg, ub4 lngflg); +sword orol (struct cda_def *lda); +sword osetpi (struct cda_def *cursor, ub1 piece, void *bufp, ub4 *lenp); + +void sqlld2 (struct cda_def *lda, OraText *cname, sb4 *cnlen); +void sqllda (struct cda_def *lda); + +/* non-blocking functions */ +sword onbset (struct cda_def *lda ); +sword onbtst (struct cda_def *lda ); +sword onbclr (struct cda_def *lda ); +sword ognfd (struct cda_def *lda, void *fdp); + + +/* + * OBSOLETE CALLS + */ + +/* + * OBSOLETE BIND CALLS + */ +sword obndra(struct cda_def *cursor, OraText *sqlvar, sword sqlvl, + ub1 *progv, sword progvl, sword ftype, sword scale, + sb2 *indp, ub2 *alen, ub2 *arcode, ub4 maxsiz, + ub4 *cursiz, OraText *fmt, sword fmtl, sword fmtt); +sword obndrn(struct cda_def *cursor, sword sqlvn, ub1 *progv, + sword progvl, sword ftype, sword scale, sb2 *indp, + OraText *fmt, sword fmtl, sword fmtt); +sword obndrv(struct cda_def *cursor, OraText *sqlvar, sword sqlvl, + ub1 *progv, sword progvl, sword ftype, sword scale, + sb2 *indp, OraText *fmt, sword fmtl, sword fmtt); + +/* + * OBSOLETE DEFINE CALLS + */ +sword odefin(struct cda_def *cursor, sword pos, ub1 *buf, + sword bufl, sword ftype, sword scale, sb2 *indp, + OraText *fmt, sword fmtl, sword fmtt, ub2 *rlen, ub2 *rcode); + +/* older calls ; preferred equivalent calls above */ + +sword oname (struct cda_def *cursor, sword pos, sb1 *tbuf, + sb2 *tbufl, sb1 *buf, sb2 *bufl); +sword orlon (struct cda_def *lda, ub1 *hda, + OraText *uid, sword uidl, + OraText *pswd, sword pswdl, + sword audit); +sword olon (struct cda_def *lda, OraText *uid, sword uidl, + OraText *pswd, sword pswdl, sword audit); +sword osql3 (struct cda_def *cda, OraText *sqlstm, sword sqllen); +sword odsc (struct cda_def *cursor, sword pos, sb2 *dbsize, + sb2 *fsize, sb2 *rcode, sb2 *dtype, sb1 *buf, + sb2 *bufl, sb2 *dsize); + +#endif /* OCIAPR */ diff --git a/OCI/include/ocidef.h b/OCI/include/ocidef.h new file mode 100644 index 0000000..9fde50b --- /dev/null +++ b/OCI/include/ocidef.h @@ -0,0 +1,886 @@ +/* Copyright (c) 1981, 2005, Oracle. All rights reserved. */ +/* Copyright (c) 1984, 2005, Oracle. All rights reserved. */ + +/* +NAME + ocidef +CONTENTS + Oracle Call Interface cursor area and LDA definitions +NOTES + none +OWNER + Oates +DATE + 09/07/82 +MODIFIED + mbastawa 09/16/05 - dbhygiene + dmukhin 06/29/05 - ANSI prototypes; miscellaneous cleanup + srseshad 03/25/03 - convert oci public api to ansi + csteinba 11/05/02 - bug 2521931: redefine OTYACL + aahluwal 06/03/02 - bug 2360115 + bpalaval 02/08/01 - Change text to oratext. + chliang 02/01/01 - fix olint error. + bpalaval 11/16/00 - Bug 1244685 : Fix ALTER CLUSTER issue.. + slari 11/08/00 - remove functions duplicated in ociapr.h + whe 09/01/99 - 976457:check __cplusplus for C++ code + skmishra 04/23/97 - Provide C++ compatibility + lchidamb 06/26/96 - put upidef.h, riddef.h within #ifndef + slari 06/12/96 - add ocigft_getFcnType + dchatter 11/10/95 - ocignfd - oci get native file descriptor + slari 05/11/95 - change OCIEVDEF/OCIEVTSF to UPIEVDEF/UPIEVTSF + dchatter 04/06/95 - add ifdef flags around OCI_flags + lchidamb 04/06/95 - drop maxdsz from ocibndps/ocidfnps + slari 04/07/95 - rename opinit to ocipin + slari 03/13/95 - thread safety changes + dchatter 03/08/95 - piece definitions OCI_*_PIECE + lchidamb 12/06/94 - add support for binding/defining with skips + dchatter 03/06/95 - merge changes from branch 1.12.720.1 + dchatter 02/06/95 - add defines for login mode parameters + dchatter 07/06/94 - Deleting CRSCHK, with refcursor, no way to set this + dchatter 06/13/94 - add a new LDA flag LDANBL + rkooi 11/18/92 - update ocidpr interface + mmoore 10/31/92 - add ocidpr + gpongrac 11/17/92 - fix oexfet prototype + sjain 01/03/92 - Add ocibra + rjenkins 11/04/91 - adding prototypes for oparse and oexfet + sjain 04/15/91 - Change ocistf proto + sjain 04/01/91 - Rearrange oty codes. Add new ones + Jain 12/03/90 - Add #define for new describe call + Jain 11/29/90 - Add new function code for the new oci calls + Mendels 01/20/89 - fix 19170: make ocitbl CONST_DATA + Kabcene 01/27/88 - change interfaces to match V5 + Navab 12/09/87 - add a parameter to ocierr call + Navab 11/30/87 - add ocierr, rename ocioer + Navab 10/08/87 - add prototypes for procedure declarations + Howard 09/07/87 - endif blah + Howard 05/11/87 - Add OTY types + Howard 04/27/87 - move ocldef defines here + Oates 10/15/85 - Add OCANCEL + Oates 09/30/85 - Implement ORA*Net + Oates 06/27/85 - Make datatype compatible with upidef.h + Andy 05/07/85 - delete CSRFBPIC +*/ + +#ifndef UPIDEF +#include +#endif + +#ifndef RIDDEF +#include +#endif + +#include + +#ifndef OCIDEF +#define OCIDEF + + +#define CSRCHECK 172 /* csrdef is a cursor */ +#define LDACHECK 202 /* csrdef is a login data area */ +struct csrdef +{ + sb2 csrrc; /* return code: v2 codes, v4 codes negative */ + ub2 csrft; /* function type */ + ub4 csrrpc; /* rows processed count */ + ub2 csrpeo; /* parse error offset */ + ub1 csrfc; /* function code */ + ub1 csrlfl; /* lda flag to indicate type of login */ + ub2 csrarc; /* actual untranslated return code */ + ub1 csrwrn; /* warning flags */ + ub1 csrflg; /* error action */ + sword csrcn; /* cursor number */ + riddef csrrid; /* rowid structure */ + sword csrose; /* os dependent error code */ + ub1 csrchk; /* check byte = CSRCHECK - in cursor */ + /* check byte = LDACHECK - in LDA */ + struct hstdef *csrhst; /* pointer to the hst */ +}; +typedef struct csrdef csrdef; +typedef struct csrdef ldadef; /* lda is the same as a csr */ + + +/* values for csrlfl */ +#define LDAFLG 1 /* ...via ologon */ +#define LDAFLO 2 /* ...via olon or orlon */ +#define LDANBL 3 /* ...nb logon in progress */ + +/* valuses for crsfc */ +#define csrfpa 2 /* ...OSQL */ +#define csrfex 4 /* ...OEXEC */ +#define csrfbi 6 /* ...OBIND */ +#define csrfdb 8 /* ...ODFINN */ +#define csrfdi 10 /* ...ODSRBN */ +#define csrffe 12 /* ...OFETCH */ +#define csrfop 14 /* ...OOPEN */ +#define csrfcl 16 /* ...OCLOSE */ +#define csrfds 22 /* ...ODSC */ +#define csrfnm 24 /* ...ONAME */ +#define csrfp3 26 /* ...OSQL3 */ +#define csrfbr 28 /* ...OBNDRV */ +#define csrfbx 30 /* ...OBNDRN */ +/*#defe csrfdf 32*/ /* ???? */ +#define csrfso 34 /* ...OOPT */ +#define csrfre 36 /* ...ORESUM */ +#define csrfbn 50 /* ...OBINDN */ +#define csrfca 52 /* ..OCANCEL */ +#define csrfsd 54 /* ..OSQLD */ +#define csrfef 56 /* ..OEXFEN */ +#define csrfln 58 /* ..OFLNG */ +#define csrfdp 60 /* ..ODSCSP */ +#define csrfba 62 /* ..OBNDRA */ +#define csrfbps 63 /*..OBINDPS */ +#define csrfdps 64 /*..ODEFINPS */ +#define csrfgpi 65 /* ...OGETPI */ +#define csrfspi 66 /* ...OSETPI */ + +/* values for csrwrn */ +#define CSRWANY 0x01 /* there is a warning flag set */ +#define CSRWTRUN 0x02 /* a data item was truncated */ +#define CSRWNVIC 0x04 /* NULL values were used in an aggregate function */ +#define CSRWITCE 0x08 /* column count not equal to into list count */ +#define CSRWUDNW 0x10 /* update or delete without where clause */ +#define CSRWRSV0 0x20 +#define CSRWROLL 0x40 /* rollback required */ +#define CSRWRCHG 0x80 /* change after query start on select for update */ + +/* values fro csrflg */ +#define CSRFSPND 0x01 /* current operation suspended */ +#define CSRFATAL 0x02 /* fatal operation: transaction rolled back */ +#define CSRFBROW 0x04 /* current row backed out */ +#define CSRFREFC 0x08 /* ref cursor type CRSCHK disabled for this cursor */ +#define CSRFNOAR 0x10 /* ref cursor type binds, so no array bind/execute */ + +/* define function codes; in order of octdef.h */ +#define OTYCTB 1 /* CREATE TABLE */ +#define OTYSER 2 /* set role */ +#define OTYINS 3 /* INSERT */ +#define OTYSEL 4 /* SELECT */ +#define OTYUPD 5 /* UPDATE */ +#define OTYDRO 6 /* drop role */ +#define OTYDVW 7 /* DROP VIEW */ + /* once was validate index */ + /* once was create partition */ + /* once was alter partition */ +#define OTYDTB 8 /* DROP TABLE */ + /* once was alter space */ + /* once was drop space */ +#define OTYDEL 9 /* DELETE */ +#define OTYCVW 10 /* create view */ +#define OTYDUS 11 /* drop user */ +#define OTYCRO 12 /* create role */ +#define OTYCSQ 13 /* create sequence */ +#define OTYASQ 14 /* alter sequence */ +#define OTYACL 15 /* alter cluster */ +#define OTYDSQ 16 /* drop sequence */ +#define OTYCSC 17 /* create schema */ +#define OTYCCL 18 /* CREATE CLUSTER */ + /* once was alter cluster */ +#define OTYCUS 19 /* create user */ +#define OTYCIX 20 /* CREATE INDEX */ +#define OTYDIX 21 /* DROP INDEX */ +#define OTYDCL 22 /* DROP CLUSTER */ +#define OTYVIX 23 /* validate index */ +#define OTYCPR 24 /* create procedure */ +#define OTYAPR 25 /* alter procedure */ +#define OTYATB 26 /* alter table */ + /* once was evaluate */ +#define OTYXPL 27 /* explain */ +#define OTYGRA 28 /* grant */ +#define OTYREV 29 /* revoke */ +#define OTYCSY 30 /* create synonym */ +#define OTYDSY 31 /* drop synonym */ +#define OTYASY 32 /* alter system switch log */ +#define OTYSET 33 /* set transaction */ +#define OTYPLS 34 /* pl/sql execute */ +#define OTYLTB 35 /* lock */ +#define OTYNOP 36 /* noop */ +#define OTYRNM 37 /* rename */ +#define OTYCMT 38 /* comment */ +#define OTYAUD 39 /* audit */ +#define OTYNOA 40 /* no audit */ +#define OTYAIX 41 /* ALTER INDEX */ +#define OTYCED 42 /* create external database */ +#define OTYDED 43 /* drop external database */ +#define OTYCDB 44 /* create database */ +#define OTYADB 45 /* alter database */ +#define OTYCRS 46 /* create rollback segment */ +#define OTYARS 47 /* alter rollback segment */ +#define OTYDRS 48 /* drop rollback segment */ +#define OTYCTS 49 /* create tablespace */ +#define OTYATS 50 /* alter tablespace */ +#define OTYDTS 51 /* drop tablespace */ +#define OTYASE 52 /* alter session */ +#define OTYAUR 53 /* alter user */ +#define OTYCWK 54 /* commit (work) */ +#define OTYROL 55 /* rollback */ +#define OTYSPT 56 /* savepoint */ + +/* For number greater than 56 the the type is the same as defined in +** octdef.h for that number. So for completion look at octdef.h +*/ + +#define OTYDEV OTYCVW /* old DEFINE VIEW = create view */ + +/* FUNCTION CODES */ +#define OCLFPA 2 /* parse - OSQL */ +#define OCLFEX 4 /* execute - OEXEC */ +#define OCLFBI 6 /* BIND by name - OBIND */ +#define OCLFDB 8 /* define buffer - ODEFIN */ +#define OCLFDI 10 /* describe item - ODSC */ +#define OCLFFE 12 /* fetch - OFETCH */ +#define OCLFOC 14 /* open cursor - OOPEN */ +# define OCLFLI OCLFOC /* old name for open cursor - OOPEN */ +#define OCLFCC 16 /* close cursor - OCLOSE */ +# define OCLFLO OCLFCC /* old name for close cursor - OCLOSE */ +#define OCLFDS 22 /* describe - ODSC */ +#define OCLFON 24 /* get table and column names - ONAME */ +#define OCLFP3 26 /* parse - OSQL3 */ +#define OCLFBR 28 /* bind reference by name - OBNDRV */ +#define OCLFBX 30 /* bind referecne numeric - OBNDRN */ +#define OCLFSO 34 /* special function - OOPT */ +#define OCLFRE 36 /* resume - ORESUM */ +#define OCLFBN 50 /* bindn */ +#define OCLFMX 52 /* maximum function number */ + +#ifdef NEVER /* unused codes */ +# define OCLFLK 18 /* open for kernel operations */ +# define OCLFEK 20 /* execute kernel operations */ +# define OCLFOK 22 /* kernel close */ +# define OCLFIN 28 /* logon to oracle */ +# define OCLFOF 30 /* logoff from oracle */ +# define OCLFAX 32 /* allocate a context area */ +# define OCLFPI 34 /* page in context area */ +# define OCLFIS 36 /* special system logon */ +# define OCLFCO 38 /* cancel the current operation */ +# define OCLFGI 40 /* get database id */ +# define OCLFJN 42 /* journal operation */ +# define OCLFCL 44 /* cleanup prior execute operation */ +# define OCLFMC 46 /* map a cursor area */ +# define OCLFUC 48 /* unmap cursor and restore user maping */ +#endif /*NEVER *//* obsolete codes */ + + +/* values for ocimode in ocipin call */ + +#define OCIEVDEF UPIEVDEF /* default : non-thread safe enivronment */ +#define OCIEVTSF UPIEVTSF /* thread-safe environment */ + + +/* OCIL* flags used to determine the mode of login, using ocilog(). +** Currently defined only for non-blocking and thread-safe logins. +*/ + +#define OCILMDEF UPILMDEF /* default, regular login */ +#define OCILMNBL UPILMNBL /* non-blocking logon */ +#define OCILMESY UPILMESY /* thread safe but external sync */ +#define OCILMISY UPILMISY /* internal sync, we do it */ +#define OCILMTRY UPILMTRY /* try to, but do not block on mutex */ + + +/* + * since sqllib uses both ocidef and ocidfn the following defines + * need to be guarded + */ +#ifndef OCI_FLAGS +#define OCI_FLAGS + +/* OCI_*_PIECE defines the piece types that are returned or set +*/ + +#define OCI_ONE_PIECE UPI_ONE_PIECE /* there or this is the only piece */ +#define OCI_FIRST_PIECE UPI_FIRST_PIECE /* the first of many pieces */ +#define OCI_NEXT_PIECE UPI_NEXT_PIECE /* the next of many pieces */ +#define OCI_LAST_PIECE UPI_LAST_PIECE /* the last piece of this column */ +#endif + +/* +** OCITAB: define return code pairs for version 2 to 3 conversions +*/ +struct ocitab +{ + sb2 ocitv3; /* Version 3/4 return code */ + sb2 ocitv2; /* Version 2 equivalent return code */ +}; +typedef struct ocitab ocitab; + +externref const ocitab ocitbl[]; + +/* macros to check cursors and LDA's. */ +/* macros to set error codes */ + +# define CRSCHK(c) if ((c->csrchk != CSRCHECK)\ + && !bit(c->csrflg, CSRFREFC))\ + return(ocir32(c, OER(1001))) +# define ldaerr(l, e) ( l->csrrc = (sb2)(-( l->csrarc = (ub2)(e)) ) ) +# define LDACHK(l) if (l->csrchk != LDACHECK) \ + return(ldaerr(l, OER(1001))) + + +/************************************************/ +/* OCI PROCEDURE DECLARATIONS */ +/************************************************/ + + + + +/*****************************/ +/* Database logon/logout */ +/*****************************/ +sword ocilog( ldadef *lda, struct hstdef *hst, oratext *uid, sword uidl, + oratext *psw, sword pswl, oratext* conn, sword connl, + ub4 mode ); +sword ocilon( ldadef *lda, oratext *uid, sword uidl, oratext *psw, + sword pswl, sword audit ); +sword ocilgi( ldadef *lda, sb2 areacount ); +sword ocirlo( ldadef *lda, struct hstdef *hst, oratext *uid, sword uidl, + oratext *psw, sword pswl, sword audit ); + /* ocilon - logon to oracle + ** ocilgi - version 2 compatible ORACLE logon call. + ** no login to ORACLE is performed: the LDA is initialized + ** ocirlo - version 5 compatible ORACLE Remote Login call, + ** oracle login is executed. + ** lda - pointer to ldadef + ** uid - user id [USER[/PASSWORD]] + ** uidl - length of uid, if -1 strlen(uid) is used + ** psw - password string; ignored if specified in uid + ** pswl - length of psw, if -1 strlen(psw) is used + ** audit - is not supported; the only permissible value is 0 + ** areacount - unused + */ + +sword ocilof( ldadef *lda ); + /* + ** ocilof - disconnect from ORACLE + ** lda - pointer to ldadef + */ + + +/*********************/ +/* Error Messages */ +/*********************/ +sword ocierr( ldadef *lda, sb2 rcode, oratext *buffer, sword bufl ); +sword ocidhe( sb2 rcode, oratext *buffer ); + /* + ** Move the text explanation for an ORACLE error to a user defined buffer + ** ocierr - will return the message associated with the hstdef stored + ** in the lda. + ** ocidhe - will return the message associated with the default host. + ** lda - lda associated with the login session + ** rcode - error code as returned by V3 call interface + ** buffer - address of a user buffer of at least 132 characters + */ + + +/***********************/ +/* Cursor Open/Close */ +/***********************/ +sword ociope( struct csrdef *cursor, ldadef *lda, oratext *dbn, sword dbnl, + sword areasize, oratext *uid, sword uidl ); + +sword ociclo( struct csrdef *cursor ); + /* + ** open or close a cursor. + ** cursor - pointer to csrdef + ** ldadef - pointer to ldadef + ** dbn - unused + ** dbnl - unused + ** areasize - if (areasize == -1) areasize <- system default initial size + ** else if (areasize IN [1..256]) areasize <- areasize * 1024; + ** most applications should use the default size since context + ** areas are extended as needed until memory is exhausted. + ** uid - user id + ** uidl - userid length + */ + +/***********************************/ +/* CONTROL AND OPTIONS */ +/***********************************/ +sword ocibre( ldadef *lda ); + /* + ** ocibrk - Oracle Call Interface send BReaK Sends a break to + ** oracle. If oracle is active, the current operation is + ** cancelled. May be called asynchronously. DOES NOT SET + ** OERRCD in the hst. This is because ocibrk may be called + ** asynchronously. Callers must test the return code. + ** lda - pointer to a ldadef + */ + +sword ocican( struct csrdef *cursor ); + /* + ** cancel the operation on the cursor, no additional OFETCH calls + ** will be issued for the existing cursor without an intervening + ** OEXEC call. + ** cursor - pointer to csrdef + */ + +sword ocisfe( struct csrdef *cursor, sword erropt, sword waitopt ); + /* + ** ocisfe - user interface set error options + ** set the error and cursor options. + ** allows user to set the options for dealing with fatal dml errors + ** and other cursor related options + ** see oerdef for valid settings + ** cursor - pointer to csrdef + ** erropt - error optionsn + ** waitopr - wait options + */ + + +/***************************************/ +/* COMMIT/ROLLBACK/AUTOCOMMIT */ +/***************************************/ +sword ocicom( ldadef *lda ); +sword ocirol( ldadef *lda ); + /* + ** ocicom - commit the current transaction + ** ocirol - roll back the current transaction + */ + +sword ocicon( ldadef *lda ); +sword ocicof( ldadef *lda ); + /* + ** ocicon - auto Commit ON + ** ocicof - auto Commit OFf + */ + + + +/************************/ +/* parsing */ +/************************/ +sword ocisq3(struct csrdef *cursor, oratext * /* sqlstm */, sword sqllen); + /* + ** ocisq3 - user interface parse sql statement + ** cursor - pointer to csrdef + ** sqlstm - pointer to SQL statement + ** sqllen - length of SQL statement. if -1, strlen(sqlstm) is used + */ + + + +/***************************/ +/* BINDING */ +/***************************/ +/* these are for the opcode in ocibndps, ocidfnps */ +#define OCI_PCWS 0 +#define OCI_SKIP 1 + +sword ocibin( struct csrdef *cursor, oratext *sqlvar, sword sqlvl, + ub1 *progv, sword progvl, sword ftype, sword scale, + oratext *fmt, sword fmtl, sword fmtt ); +sword ocibrv( struct csrdef *cursor, oratext *sqlvar, sword sqlvl, + ub1 *progv, sword progvl, sword ftype, sword scale, sb2 *indp, + oratext *fmt, sword fmtl, sword fmtt ); +sword ocibra( struct csrdef *cursor, oratext *sqlvar, sword sqlvl, + ub1 *progv, sword progvl, sword ftype, sword scale, + sb2 *indp, ub2 *aln, ub2 *rcp, ub4 mal, ub4 *cal, + oratext *fmt, sword fmtl, sword fmtt ); +sword ocibndps( struct csrdef *cursor, ub1 opcode, oratext *sqlvar, + sb4 sqlvl, ub1 *progv, sb4 progvl, sword ftype, + sword scale, sb2 *indp, ub2 *aln, ub2 *rcp, sb4 pv_skip, + sb4 ind_skip, sb4 len_skip, sb4 rc_skip, ub4 mal, + ub4 *cal, oratext *fmt, sb4 fmtl, sword fmtt ); +sword ocibnn ( struct csrdef *cursor, ub2 sqlvn, ub1 *progv, sword progvl, + sword ftype, sword scale, oratext *fmt, sword fmtl, + sword fmtt ); +sword ocibrn( struct csrdef *cursor, sword sqlvn, ub1 *progv, sword progvl, + sword ftype, sword scale, sb2 *indp, oratext *fmt, sword fmtl, + sword fmtt ); + /* + ** ocibin - bind by value by name + ** ocibrv - bind by reference by name + ** ocibra - bind by reference by name (array) + ** ocibndps - bind by reference by name (array) piecewise or with skips + ** ocibnn - bind by value numeric + ** ocibrn - bind by reference numeric + ** + ** the contents of storage specified in bind-by-value calls are + ** evaluated immediately. + ** the addresses of storage specified in bind-by-reference calls are + ** remembered, and the contents are examined at every execute. + ** + ** cursor - pointer to csrdef + ** sqlvn - the number represented by the name of the bind variables + ** for variables of the form :n or &n for n in [1..256) + ** (i.e. &1, :234). unnecessarily using larger numbers + ** in the range wastes space. + ** sqlvar - the name of the bind variable (:name or &name) + ** sqlval - the length of the name; + ** in bindif -1, strlen(bvname) is used + ** progv - pointer to the object to bind. + ** progvl - length of object to bind. + ** in bind-by-value if specified as -1 then strlen(bfa) is + ** used (really only makes sends with character types) + ** in bind-by-value, if specified as -1 then UB2MAXVAL + ** is used. Again this really makes sense only with + ** SQLT_STR. + ** ftype - datatype of object + ** indp - pointer to indicator variable. + ** -1 means to ignore bfa/bfl and bind NULL; + ** not -1 means to bind the contents of bfa/bfl + ** bind the contents pointed to by bfa + ** aln - Alternate length pointer + ** rcp - Return code pointer + ** mal - Maximum array length + ** cal - Current array length pointer + ** fmt - format string + ** fmtl - length of format string; if -1, strlen(fmt) is used + ** fmtt - desired output type after applying forat mask. Not + ** really yet implemented + ** scale - number of decimal digits in a cobol packed decimal (type 7) + ** + ** Note that the length of bfa when bound as SQLT_STR is reduced + ** to strlen(bfa). + ** Note that trailing blanks are stripped of storage of SQLT_STR. + */ + +/***************************/ +/* DESCRIBING */ +/***************************/ +sword ocidsc ( struct csrdef *cursor, sword pos, sb2 *dbsize, sb2 *fsize, + sb2 *rcode, sb2 *dtype, sb1 *buf, sb2 *bufl, sb2 *dsize ); +sword ocidsr( struct csrdef *cursor, sword pos, sb2 *dbsize, sb2 *dtype, + sb2 *fsize ); +sword ocinam( struct csrdef *cursor, sword pos, sb1 *tbuf, sb2 *tbufl, + sb1 *buf, sb2 *bufl ); + /* + ** ocidsc, ocidsr: Obtain information about a column + ** ocinam : get the name of a column + ** cursor - pointer to csrdef + ** pos - position in select list from [1..N] + ** dbsize - place to store the database size + ** fsize - place to store the fetched size + ** rcode - place to store the fetched column returned code + ** dtype - place to store the data type + ** buf - array to store the column name + ** bufl - place to store the column name length + ** dsize - maximum display size + ** tbuf - place to store the table name + ** tbufl - place to store the table name length + */ + +sword ocidsp ( struct csrdef *cursor, sword pos, sb4 *dbsize, sb2 *dbtype, + sb1 *cbuf, sb4 *cbufl, sb4 *dsize, sb2 *pre, sb2 *scl, + sb2 *nul ); + +sword ocidpr( ldadef *lda, oratext *object_name, size_t object_length, + void * reserved1, size_t reserved1_length, void * reserved2, + size_t reserved2_length, ub2 *overload, ub2 *position, + ub2 *level, oratext **argument_name, ub2 *argument_length, + ub2 *datatype, ub1 *default_supplied, ub1 *in_out, + ub4 *length, sb2 *precision, sb2 *scale, ub1 *radix, + ub4 *spare, ub4 *total_elements ); + /* + ** OCIDPR - User Program Interface: Describe Stored Procedure + ** + ** This routine is used to obtain information about the calling + ** arguments of a stored procedure. The client provides the + ** name of the procedure using "object_name" and "database_name" + ** (database name is optional). The client also supplies the + ** arrays for OCIDPR to return the values and indicates the + ** length of array via the "total_elements" parameter. Upon return + ** the number of elements used in the arrays is returned in the + ** "total_elements" parameter. If the array is too small then + ** an error will be returned and the contents of the return arrays + ** are invalid. + ** + ** + ** EXAMPLE : + ** + ** Client provides - + ** + ** object_name - SCOTT.ACCOUNT_UPDATE@BOSTON + ** total_elements - 100 + ** + ** + ** ACCOUNT_UPDATE is an overloaded function with specification : + ** + ** type number_table is table of number index by binary_integer; + ** table account (account_no number, person_id number, + ** balance number(7,2)) + ** table person (person_id number(4), person_nm varchar2(10)) + ** + ** function ACCOUNT_UPDATE (account number, + ** person person%rowtype, amounts number_table, + ** trans_date date) return accounts.balance%type; + ** + ** function ACCOUNT_UPDATE (account number, + ** person person%rowtype, amounts number_table, + ** trans_no number) return accounts.balance%type; + ** + ** + ** Values returned - + ** + ** overload position argument level datatype length prec scale rad + ** ------------------------------------------------------------------- + ** 0 0 0 NUMBER 22 7 2 10 + ** 0 1 ACCOUNT 0 NUMBER 22 0 0 0 + ** 0 2 PERSON 0 RECORD 0 0 0 0 + ** 0 2 PERSON_ID 1 NUMBER 22 4 0 10 + ** 0 2 PERSON_NM 1 VARCHAR2 10 0 0 0 + ** 0 3 AMOUNTS 0 TABLE 0 0 0 0 + ** 0 3 1 NUMBER 22 0 0 0 + ** 0 4 TRANS_NO 0 NUMBER 22 0 0 0 + ** + ** 1 0 0 NUMBER 22 7 2 10 + ** 1 1 ACCOUNT 0 NUMBER 22 0 0 0 + ** 1 2 PERSON 0 RECORD 0 0 0 0 + ** 1 2 PERSON_ID 1 NUMBER 22 4 0 10 + ** 1 2 PERSON_NM 1 VARCHAR2 10 0 0 0 + ** 1 3 AMOUNTS 0 TABLE 0 0 0 0 + ** 1 3 1 NUMBER 22 0 0 0 + ** 1 4 TRANS_DATE 0 NUMBER 22 0 0 0 + ** + ** + ** OCIDPR Argument Descriptions - + ** + ** ldadef - pointer to ldadef + ** object_name - object name, synonyms are also accepted and will + ** be translate, currently only procedure and function + ** names are accepted, also NLS names are accepted. + ** Currently, the accepted format of a name is + ** [[part1.]part2.]part3[@dblink] (required) + ** object_length - object name length (required) + ** reserved1 - reserved for future use + ** reserved1_length - reserved for future use + ** reserved2 - reserved for future use + ** reserved2_length - reserved for future use + ** overload - array indicating overloaded procedure # (returned) + ** position - array of argument positions, position 0 is a + ** function return argument (returned) + ** level - array of argument type levels, used to describe + ** sub-datatypes of data structures like records + ** and arrays (returned) + ** argument_name - array of argument names, only returns first + ** 30 characters of argument names, note storage + ** for 30 characters is allocated by client (returned) + ** argument_length - array of argument name lengths (returned) + ** datatype - array of oracle datatypes (returned) + ** default_supplied - array indicating parameter has default (returned) + ** 0 = no default, 1 = default supplied + ** in_out - array indicating if argument is IN or OUT (returned + ** 0 = IN param, 1 = OUT param, 2 = IN/OUT param + ** length - array of argument lengths (returned) + ** precision - array of precisions (if number type)(returned) + ** scale - array of scales (if number type)(returned) + ** radix - array of radix (if number type)(returned) + ** spare - array of spares. + ** total_elements - size of arrays supplied by client (required), + ** total number of elements filled (returned) + */ + +/*************************************/ +/* DEFINING */ +/*************************************/ +sword ocidfi( struct csrdef *cursor, sword pos, ub1 *buf, sword bufl, + sword ftype, sb2 *rc, sword scale ); +sword ocidfn( struct csrdef *cursor, sword pos, ub1 *buf, sword bufl, + sword ftype, sword scale, sb2 *indp, oratext *fmt, sword fmtl, + sword fmtt, ub2 *rl, ub2 *rc ); +sword ocidfnps( struct csrdef *cursor, ub1 opcode, sword pos, ub1 *buf, + sb4 bufl, sword ftype, sword scale, + sb2 *indp, oratext *fmt, sb4 fmtl, + sword fmtt, ub2 *rl, ub2 *rc, + sb4 pv_skip, sb4 ind_skip, sb4 len_skip, + sb4 rc_skip ); + + + /* Define a user data buffer using upidfn + ** cursor - pointer to csrdef + ** pos - position of a field or exp in the select list of a query + ** bfa/bfl - address and length of client-supplied storage + to receive data + ** ftype - user datatype + ** scale - number of fractional digits for cobol packed decimals + ** indp - place to store the length of the returned value. If returned + ** value is: + ** negative, the field fetched was NULL + ** zero , the field fetched was same length or shorter than + ** the buffer provided + ** positive, the field fetched was truncated + ** fmt - format string + ** fmtl - length of format string, if -1 strlent(fmt) used + ** rl - place to store column length after each fetch + ** rc - place to store column error code after each fetch + ** fmtt - fomat type + */ + +/********************************/ +/* PIECE INFORMATION GET/SET */ +/********************************/ +sword ocigetpi( struct csrdef *cursor, ub1 *piecep, + void **ctxpp, ub4 *iterp, ub4 *indexp ); +sword ocisetpi( struct csrdef *cursor, ub1 piece, + void *bufp, ub4 *lenp ); + + +/********************************/ +/* EXECUTE */ +/********************************/ +sword ociexe( struct csrdef *cursor ); +sword ociexn( struct csrdef *cursor, sword iters, sword roff ); +sword ociefn( struct csrdef *cursor, ub4 nrows, sword can, sword exact ); + /* + ** ociexe - execute a cursor + ** ociexn - execute a cursosr N times + ** cursor - pointer to a csrdef + ** iters - number of times to execute cursor + ** roff - offset within the bind variable array at which to begin + ** operations. + */ + + +/*********************************/ +/* FETCHING */ +/*********************************/ +sword ocifet( struct csrdef *cursor ); +sword ocifen( struct csrdef *cursor, sword nrows ); + /* ocifet - fetch the next row + ** ocifen - fetch n rows + ** cursor - pointer to csrdef + ** nrows - number of rows to be fetched + */ + +sword ocilng( struct csrdef *cursor, sword posit, ub1 *bfa, sb4 bfl, + sword dty, ub4 *rln, sb4 off ); + +/*********************************/ +/* CONVERSION */ +/*********************************/ +sword ocic32( struct csrdef *cursor ); + /* + ** Convert selected version 3 return codes to the equivalent + ** version 2 code. + ** csrdef->csrrc is set to the converted code + ** csrdef->csrft is set to v2 oracle statment type + ** csrdef->csrrpc is set to the rows processed count + ** csrdef->csrpeo is set to error postion + ** + ** cursor - pointer to csrdef + */ + + +sword ocir32( struct csrdef *cursor, sword retcode ); + /* + ** Convert selected version 3 return codes to the equivalent version 2 + ** code. + ** + ** cursor - pointer to csrdef + ** retcode - place to store the return code + */ + + +void ociscn( sword **arglst, char *mask_addr, sword **newlst ); + /* + ** Convert call-by-ref to call-by-value: + ** takes an arg list and a mask address, determines which args need + ** conversion to a value, and creates a new list begging at the address + ** of newlst. + ** + ** arglst - list of arguments + ** mast_addr _ mask address determines args needing conversion + ** newlst - new list of args + */ + +sword ocistf ( sword typ, sword bufl, sword rdig, oratext *fmt, + struct csrdef *cursor, sword *err ); +/* Convert a packed decimal buffer length (bytes) and scale to a format +** string of the form mm.+/-nn, where mm is the number of packed +** decimal digits, and nn is the scaling factor. A positive scale name +** nn digits to the rights of the decimal; a negative scale means nn zeros +** should be supplied to the left of the decimal. +** bufl - length of the packed decimal buffer +** rdig - number of fractional digits +** fmt - pointer to a string holding the conversion format +** cursor - pointer to csrdef +** err - pointer to word storing error code +*/ + + +/******************************************/ +/* Non-blocking operations */ +/******************************************/ +sword ocinbs( ldadef *lda ); /* set a connection to non-blocking */ +sword ocinbt( ldadef *lda ); /* test if connection is non-blocking */ +sword ocinbc( ldadef *lda ); /* clear a connection to blocking */ +sword ocinlo( ldadef *lda, struct hstdef *hst, oratext *conn, + sword connl, oratext *uid, sword uidl, + oratext *psw, sword pswl, sword audit ); + /* logon in non-blocking fashion */ +/* ocinlo allows an application to logon in non-blocking fashion. +** lda - pointer to ldadef +** hst - pointer to a 256 byte area, must be cleared to zero before call +** conn - the database link (if specified @LINK in uid will be ignored) +** connl - length of conn; if -1 strlen(conn) is used +** uid - user id [USER[/PASSWORD][@LINK]] +** uidl - length of uid, if -1 strlen(uid) is used +** psw - password string; ignored if specified in uid +** pswl - length of psw, if -1 strlen(psw) is used +** audit - is not supported; the only permissible value is 0 +*/ + +/***************************************************/ +/* Procedure Declaration for Pro*C */ +/***************************************************/ +/* Note: The following routines are used in Pro*C and have the + same interface as their couterpart in OCI. + Althought the interface follows for more details please refer + to the above routines */ + +/******************************************/ +/* initialization/logon/logof */ +/******************************************/ +sword ocipin( ub4 mode ); + +sword ologin( ldadef *lda, sb2 areacount ); +sword ologon( ldadef *lda, sb2 areacount ); + +/*****************************************/ +/* Open/Close/Parse Cursor */ +/*****************************************/ + +/* +** ocisqd - oci delayed parse (Should be used only with deferred upi/oci) +** FUNCTION: Call upidpr to delay the parse of the sql statement till the +** time that a call needs to be made to the kernel (execution or +** describe time ) +** RETURNS: Oracle return code. +*/ +sword ocisq7( struct csrdef *cursor, oratext * /* sqlstm */, sb4 sqllen, + sword defflg, ub4 sqlt ); + +/*****************************************/ +/* Bind */ +/*****************************************/ +sword obind( struct csrdef *cursor, oratext *sqlvar, sword sqlvl, + ub1 *progv, sword progvl, sword ftype, sword scale, + oratext *fmt, sword fmtl, sword fmtt ); +sword obindn( struct csrdef *cursor, ub2 sqlvn, ub1 *progv, sword progvl, + sword ftype, sword scale, oratext *fmt, sword fmtl, + sword fmtt ); + +/**********************************************/ +/* Define */ +/**********************************************/ +sword odfinn( struct csrdef *cursor, sword pos, ub1 *buf, sword bufl, + sword ftype, sb2 *rc, sword scale ); + +/**********************************************/ +/* Describe */ +/**********************************************/ +sword odsrbn( struct csrdef *cursor, sword pos, sb2 *dbsize, sb2 *dtype, + sb2 *fsize ); + + +/******************************************/ +/* Non-blocking operations */ +/******************************************/ +sword onblon( ldadef *lda, struct hstdef *hst, oratext *conn, + sword connl, oratext *uid, sword uidl, + oratext *psw, sword pswl, sword audit ); + /* logon in non-blocking fashion */ +sword ocignfd( ldadef *lda, void *nfdp ); /* get native fd */ + +ub2 ocigft_getFcnType( ub2 oertyp ); /* get sql function code */ + +#endif diff --git a/OCI/include/ocidem.h b/OCI/include/ocidem.h new file mode 100644 index 0000000..f7bb786 --- /dev/null +++ b/OCI/include/ocidem.h @@ -0,0 +1,113 @@ +/* + * + */ + +/* Copyright (c) 1991, 2005, Oracle. All rights reserved. */ +/* Copyright (c) 1991, 2005, Oracle. All rights reserved. */ +/* + NAME + ocidem.h - OCI demo header + MODIFIED (MM/DD/YY) + dmukhin 06/29/05 - ANSI prototypes; miscellaneous cleanup + whe 04/07/99 - bug#810071 + whe 03/19/99 - lrg 32079 etc.: putting static back for oci_func_tab + nmacnaug 02/02/99 - static declarations should not be in header files + mygopala 09/22/97 - Fix for bug 550351 + surman 03/14/97 - Merge 413362 to 8.0.3 + surman 11/08/96 - 413362: Add SS_64BIT_SERVER macro + emendez 04/07/94 - merge changes from branch 1.6.710.1 + emendez 02/02/94 - Fix for bug 157576 + jnlee 01/05/93 - include oratypes.h once, make oci_func_tab static + rkooi2 10/26/92 - More portability mods + rkooi2 10/22/92 - Change text back to char to avoid casts + rkooi2 10/20/92 - Changes to make it portable + sjain 03/16/92 - Creation +*/ + +/* + * ocidem.h + * + * Declares additional functions and data structures + * used in the OCI C sample programs. + */ + + +#ifndef ORATYPES +#include +#endif /* ORATYPES */ + +#ifndef OCIDFN +#include +#endif /* OCIDFN */ + +#ifndef OCIDEM +#define OCIDEM + + +/* internal/external datatype codes */ +#define VARCHAR2_TYPE 1 +#define NUMBER_TYPE 2 +#define INT_TYPE 3 +#define FLOAT_TYPE 4 +#define STRING_TYPE 5 +#define ROWID_TYPE 11 +#define DATE_TYPE 12 + +/* ORACLE error codes used in demonstration programs */ +#define VAR_NOT_IN_LIST 1007 +#ifndef NO_DATA_FOUND +# define NO_DATA_FOUND 1403 +#endif +#define NULL_VALUE_RETURNED 1405 + +/* some SQL and OCI function codes */ +#define FT_INSERT 3 +#define FT_SELECT 4 +#define FT_UPDATE 5 +#define FT_DELETE 9 + +#define FC_OOPEN 14 + +/* + * OCI function code labels, + * corresponding to the fc numbers + * in the cursor data area. + */ +static const text *oci_func_tab[] = {(text *) "not used", +/* 1-2 */ (text *) "not used", (text *) "OSQL", +/* 3-4 */ (text *) "not used", (text *) "OEXEC, OEXN", +/* 5-6 */ (text *) "not used", (text *) "OBIND", +/* 7-8 */ (text *) "not used", (text *) "ODEFIN", +/* 9-10 */ (text *) "not used", (text *) "ODSRBN", +/* 11-12 */ (text *) "not used", (text *) "OFETCH, OFEN", +/* 13-14 */ (text *) "not used", (text *) "OOPEN", +/* 15-16 */ (text *) "not used", (text *) "OCLOSE", +/* 17-18 */ (text *) "not used", (text *) "not used", +/* 19-20 */ (text *) "not used", (text *) "not used", +/* 21-22 */ (text *) "not used", (text *) "ODSC", +/* 23-24 */ (text *) "not used", (text *) "ONAME", +/* 25-26 */ (text *) "not used", (text *) "OSQL3", +/* 27-28 */ (text *) "not used", (text *) "OBNDRV", +/* 29-30 */ (text *) "not used", (text *) "OBNDRN", +/* 31-32 */ (text *) "not used", (text *) "not used", +/* 33-34 */ (text *) "not used", (text *) "OOPT", +/* 35-36 */ (text *) "not used", (text *) "not used", +/* 37-38 */ (text *) "not used", (text *) "not used", +/* 39-40 */ (text *) "not used", (text *) "not used", +/* 41-42 */ (text *) "not used", (text *) "not used", +/* 43-44 */ (text *) "not used", (text *) "not used", +/* 45-46 */ (text *) "not used", (text *) "not used", +/* 47-48 */ (text *) "not used", (text *) "not used", +/* 49-50 */ (text *) "not used", (text *) "not used", +/* 51-52 */ (text *) "not used", (text *) "OCAN", +/* 53-54 */ (text *) "not used", (text *) "OPARSE", +/* 55-56 */ (text *) "not used", (text *) "OEXFET", +/* 57-58 */ (text *) "not used", (text *) "OFLNG", +/* 59-60 */ (text *) "not used", (text *) "ODESCR", +/* 61-62 */ (text *) "not used", (text *) "OBNDRA", +/* 63-64 */ (text *) "OBINDPS", (text *) "ODEFINPS", +/* 65-66 */ (text *) "OGETPI", (text *) "OSETPI" +}; + +#endif /* OCIDEM */ + diff --git a/OCI/include/ocidfn.h b/OCI/include/ocidfn.h new file mode 100644 index 0000000..873c5a7 --- /dev/null +++ b/OCI/include/ocidfn.h @@ -0,0 +1,249 @@ +/* Copyright (c) 1991, 2005, Oracle. All rights reserved. */ +/* Copyright (c) 1991, 2005, Oracle. All rights reserved. */ +/* + NAME + ocidfn.h - OCI Definations + NOTES + Shipped to users. + MODIFIED (MM/DD/YY) + mbastawa 09/16/05 - dbhygiene + dmukhin 06/29/05 - ANSI prototypes; miscellaneous cleanup + srseshad 11/25/02 - change binary float/double codes + srseshad 11/14/02 - Add SQLT_IBFLOAT, SQLT_IBDOUBLE + mxyang 09/17/02 - grabtrans 'mmorsi_obj_float' + srseshad 09/06/02 - Add binary float/double + aahluwal 06/04/02 - bug 2360115 + kmuthukk 05/02/00 - add SQLT_PNTY + amangal 07/30/99 - Merge into 8.1.6 : Bug 879031 + tnbui 07/28/99 - Remove SQLT_TIMESTAMP_ITZ + tnbui 07/21/99 - SQLT_TIMESTAMP_LTZ + tnbui 06/16/99 - TIMESTAMP WITH IMPLICIT TIME ZONE + whe 04/07/99 - bug#810075 + whe 03/19/99 - lrg 32079 etc.: move HDA def from ocidem.h to ocidfn. + skmishra 05/10/98 - + vyanaman 04/16/98 - update sql92 datatypes + khnguyen 01/16/98 - + khnguyen 12/23/97 - SQLT* for datetimes and intervals + tanguyen 08/19/97 - + dchatter 03/18/97 - porting exception 390897 + dchatter 05/02/97 - merge porting exception + dalpern 12/04/96 - SQLCS_LIT_NULL added + cxcheng 11/14/96 - add SQLT_BFILE/SQLT_CFILE to fix compile prob + cxcheng 11/12/96 - add SQLT_NCO for named collection + lchidamb 10/17/96 - add SQLT_VST and SQLT_ODT + sgollapu 10/14/96 - Mutual exclusion of ocidfn and sqldef + sgollapu 10/07/96 - OCI Simplification + aroy 09/09/96 - add SQLCS* definitions + slari 08/07/96 - add SQLT_RDD, rowid descriptor + slari 06/12/96 - remove SQLT_TTBL + dchatter 04/21/96 - prepare for merge into main + slari 08/24/95 - b299432, define CDA_SIZE + zwalcott 02/28/96 - add SQLT_BFILEE and SQLT_CFILEE. + lchidamb 02/22/96 - make dtys consistent with dtydef.h + lchidamb 02/16/96 - add SQLT_BFILEE and SQLT_CFILEE + lchidamb 01/30/96 - rename new datatypes for v8 + lchidamb 09/06/95 - add new datatypes + slari 05/11/95 - add OCI_EV_DEF and OCI_EV_TSF + dchatter 04/06/95 - add ifdef flags around OCI_flags + dchatter 03/08/95 - piece values + dchatter 03/06/95 - merge changes from branch 1.2.720.3 + jfbrown 02/17/95 - merge changes from branch 1.2.720.2 + dchatter 02/08/95 - olog call modes + jfbrown 02/03/95 - remove non-printable characters + lchidamb 12/06/94 - merge changes from branch 1.2.720.1 + lchidamb 10/04/94 - added field chk to cda_head, cda_def + dchatter 07/05/94 - SQLT_CUR added + rkooi2 11/27/92 - Changing e* datatypes to s* + rkooi2 10/26/92 - More portability mods + rkooi2 10/22/92 - Added #ifndef ORATYPES ... + rkooi2 10/18/92 - Changes to make it portable. + sjain 03/16/92 - Creation +*/ + +/* + * ocidfn.h + * + * Common header file for OCI C sample programs. + * This header declares the cursor and logon data area structure. + * The types used are defined in . + * + */ + +#ifndef OCIDFN +#define OCIDFN + +#include + +/* The cda_head struct is strictly PRIVATE. It is used + internally only. Do not use this struct in OCI programs. */ + +struct cda_head { + sb2 v2_rc; + ub2 ft; + ub4 rpc; + ub2 peo; + ub1 fc; + ub1 rcs1; + ub2 rc; + ub1 wrn; + ub1 rcs2; + sword rcs3; + struct { + struct { + ub4 rcs4; + ub2 rcs5; + ub1 rcs6; + } rd; + ub4 rcs7; + ub2 rcs8; + } rid; + sword ose; + ub1 chk; + void *rcsp; +}; + +/* +** Size of HDA area: +** 512 for 64 bit arquitectures +** 256 for 32 bit arquitectures +*/ + +#if defined(SS_64BIT_SERVER) || defined(__64BIT__) +# define HDA_SIZE 512 +#else +# define HDA_SIZE 256 +#endif + +#if defined(SS_64BIT_SERVER) || defined(__64BIT__) +#define CDA_SIZE 88 +#else +# define CDA_SIZE 64 +#endif + +/* the real CDA, padded to CDA_SIZE bytes in size */ +struct cda_def { + sb2 v2_rc; /* V2 return code */ + ub2 ft; /* SQL function type */ + ub4 rpc; /* rows processed count */ + ub2 peo; /* parse error offset */ + ub1 fc; /* OCI function code */ + ub1 rcs1; /* filler area */ + ub2 rc; /* V7 return code */ + ub1 wrn; /* warning flags */ + ub1 rcs2; /* reserved */ + sword rcs3; /* reserved */ + struct { /* rowid structure */ + struct { + ub4 rcs4; + ub2 rcs5; + ub1 rcs6; + } rd; + ub4 rcs7; + ub2 rcs8; + } rid; + sword ose; /* OSD dependent error */ + ub1 chk; + void *rcsp; /* pointer to reserved area */ + ub1 rcs9[CDA_SIZE - sizeof (struct cda_head)]; /* filler */ +}; + +typedef struct cda_def Cda_Def; + +/* the logon data area (LDA) + is the same shape as the CDA */ +typedef struct cda_def Lda_Def; + +/* OCI Environment Modes for opinit call */ +#define OCI_EV_DEF 0 /* default single-threaded environment */ +#define OCI_EV_TSF 1 /* thread-safe environment */ + +/* OCI Logon Modes for olog call */ +#define OCI_LM_DEF 0 /* default login */ +#define OCI_LM_NBL 1 /* non-blocking logon */ + +/* + * since sqllib uses both ocidef and ocidfn the following defines + * need to be guarded + */ +#ifndef OCI_FLAGS +#define OCI_FLAGS + +/* OCI_*_PIECE defines the piece types that are returned or set +*/ +#define OCI_ONE_PIECE 0 /* there or this is the only piece */ +#define OCI_FIRST_PIECE 1 /* the first of many pieces */ +#define OCI_NEXT_PIECE 2 /* the next of many pieces */ +#define OCI_LAST_PIECE 3 /* the last piece of this column */ +#endif + +#ifndef SQLDEF + +/* input data types */ +#define SQLT_CHR 1 /* (ORANET TYPE) character string */ +#define SQLT_NUM 2 /* (ORANET TYPE) oracle numeric */ +#define SQLT_INT 3 /* (ORANET TYPE) integer */ +#define SQLT_FLT 4 /* (ORANET TYPE) Floating point number */ +#define SQLT_STR 5 /* zero terminated string */ +#define SQLT_VNU 6 /* NUM with preceding length byte */ +#define SQLT_PDN 7 /* (ORANET TYPE) Packed Decimal Numeric */ +#define SQLT_LNG 8 /* long */ +#define SQLT_VCS 9 /* Variable character string */ +#define SQLT_NON 10 /* Null/empty PCC Descriptor entry */ +#define SQLT_RID 11 /* rowid */ +#define SQLT_DAT 12 /* date in oracle format */ +#define SQLT_VBI 15 /* binary in VCS format */ +#define SQLT_BFLOAT 21 /* Native Binary float*/ +#define SQLT_BDOUBLE 22 /* NAtive binary double */ +#define SQLT_BIN 23 /* binary data(DTYBIN) */ +#define SQLT_LBI 24 /* long binary */ +#define SQLT_UIN 68 /* unsigned integer */ +#define SQLT_SLS 91 /* Display sign leading separate */ +#define SQLT_LVC 94 /* Longer longs (char) */ +#define SQLT_LVB 95 /* Longer long binary */ +#define SQLT_AFC 96 /* Ansi fixed char */ +#define SQLT_AVC 97 /* Ansi Var char */ +#define SQLT_IBFLOAT 100 /* binary float canonical */ +#define SQLT_IBDOUBLE 101 /* binary double canonical */ +#define SQLT_CUR 102 /* cursor type */ +#define SQLT_RDD 104 /* rowid descriptor */ +#define SQLT_LAB 105 /* label type */ +#define SQLT_OSL 106 /* oslabel type */ + +#define SQLT_NTY 108 /* named object type */ +#define SQLT_REF 110 /* ref type */ +#define SQLT_CLOB 112 /* character lob */ +#define SQLT_BLOB 113 /* binary lob */ +#define SQLT_BFILEE 114 /* binary file lob */ +#define SQLT_CFILEE 115 /* character file lob */ +#define SQLT_RSET 116 /* result set type */ +#define SQLT_NCO 122 /* named collection type (varray or nested table) */ +#define SQLT_VST 155 /* OCIString type */ +#define SQLT_ODT 156 /* OCIDate type */ + +/* datetimes and intervals */ +#define SQLT_DATE 184 /* ANSI Date */ +#define SQLT_TIME 185 /* TIME */ +#define SQLT_TIME_TZ 186 /* TIME WITH TIME ZONE */ +#define SQLT_TIMESTAMP 187 /* TIMESTAMP */ +#define SQLT_TIMESTAMP_TZ 188 /* TIMESTAMP WITH TIME ZONE */ +#define SQLT_INTERVAL_YM 189 /* INTERVAL YEAR TO MONTH */ +#define SQLT_INTERVAL_DS 190 /* INTERVAL DAY TO SECOND */ +#define SQLT_TIMESTAMP_LTZ 232 /* TIMESTAMP WITH LOCAL TZ */ + +#define SQLT_PNTY 241 /* pl/sql representation of named types */ + +/* cxcheng: this has been added for backward compatibility - + it needs to be here because ocidfn.h can get included ahead of sqldef.h */ +#define SQLT_FILE SQLT_BFILEE /* binary file lob */ +#define SQLT_CFILE SQLT_CFILEE +#define SQLT_BFILE SQLT_BFILEE + +/* CHAR/NCHAR/VARCHAR2/NVARCHAR2/CLOB/NCLOB char set "form" information */ +#define SQLCS_IMPLICIT 1 /* for CHAR, VARCHAR2, CLOB w/o a specified set */ +#define SQLCS_NCHAR 2 /* for NCHAR, NCHAR VARYING, NCLOB */ +#define SQLCS_EXPLICIT 3 /* for CHAR, etc, with "CHARACTER SET ..." syntax */ +#define SQLCS_FLEXIBLE 4 /* for PL/SQL "flexible" parameters */ +#define SQLCS_LIT_NULL 5 /* for typecheck of NULL and empty_clob() lits */ + +#endif /* SQLDEF */ +#endif /* OCIDFN */ diff --git a/OCI/include/ociextp.h b/OCI/include/ociextp.h new file mode 100644 index 0000000..7026a68 --- /dev/null +++ b/OCI/include/ociextp.h @@ -0,0 +1,282 @@ +/* + * + */ + +/* Copyright (c) 1996, 2005, Oracle. All rights reserved. */ + +/* + NAME + ociextp.h - Interface Definitions for PL/SQL External Procedures + + DESCRIPTION + This header file contains C language callable interface from + PL/SQL External Procedures. + + PUBLIC FUNCTION(S) + OCIExtProcAllocCallMemory - Allocate Call memory + OCIExtProcRaiseExcp - Raise Exception + OCIExtProcRaiseExcpWithMsg - Raise Exception with message + OCIExtProcGetEnv - Get OCI Environment + + PRIVATE FUNCTION(S) + + + EXAMPLES + + NOTES + + + MODIFIED (MM/DD/YY) + dmukhin 06/29/05 - ANSI prototypes; miscellaneous cleanup + srseshad 03/12/03 - convert oci public api to ansi + rdecker 01/10/02 - change 32k to MAX_OEN for error numbers + sagrawal 07/20/01 - Statement Handle to safe cal outs + abrumm 04/19/01 - move include of oci.h after defines/typedef + rdecker 02/22/01 - lint fix + bpalaval 02/08/01 - Change text to oratext. + sagrawal 06/16/00 - ref cursor in callouts + whe 09/01/99 - 976457:check __cplusplus for C++ code + asethi 04/15/99 - Created (by moving ociextp.h from /vobs/plsql/public) + rhari 03/25/97 - Use ifndef + rhari 12/18/96 - Include oratypes.h + rhari 12/11/96 - #416977, Flip values of return codes + rhari 12/02/96 - Define Return Code Macros + rhari 11/18/96 - Error number is int + rhari 10/30/96 - Fix OCIExtProcRaiseExcpWithMsg + rhari 10/30/96 - Get rid of warnings + rhari 10/04/96 - Fix OCIExtProcRaiseExcpWithMsg + rhari 09/23/96 - Creation + +*/ + + +#ifndef OCIEXTP_ORACLE +# define OCIEXTP_ORACLE + +# ifndef ORATYPES +# include +# endif + + +/*--------------------------------------------------------------------------- + PUBLIC TYPES AND CONSTANTS + ---------------------------------------------------------------------------*/ + + +/* ----------------------------- Return Codes ----------------------------- */ +/* Success and Error return codes for certain external procedure interface + * functions. If a particular interface function returns OCIEXTPROC_SUCCESS + * or OCIEXTPROC_ERROR, then applications must use these macros to check + * for return values. + * + * OCIEXTPROC_SUCCESS -- External Procedure Success Return Code + * OCIEXTPROC_ERROR -- External Procedure Failure Return Code + */ +#define OCIEXTPROC_SUCCESS 0 +#define OCIEXTPROC_ERROR 1 + + +/* --------------------------- With-Context Type --------------------------- */ +/* + * The C callable interface to PL/SQL External Procedures require the + * With-Context parameter to be passed. The type of this structure is + * OCIExtProcContext is is opaque to the user. + * + * The user can declare the With-Context parameter in the application as + * + * OCIExtProcContext *with_context; + */ +typedef struct OCIExtProcContext OCIExtProcContext; + +/* NOTE: OCIExtProcContext must be visible prior to including */ + +# ifndef OCI_ORACLE +# include +# endif + + +/* ----------------------- OCIExtProcAllocCallMemory ----------------------- */ +/* OCIExtProcAllocCallMemory + * Allocate N bytes of memory for the duration of the External Procedure. + * + * Memory thus allocated will be freed by PL/SQL upon return from the + * External Procedure. You must not use any kind of 'free' function on + * memory allocated by OCIExtProcAllocCallMemory. + * Use this function to allocate memory for function returns. + * + * PARAMETERS + * Input : + * with_context - The with_context pointer that is passed to the C + * External Procedure. + * Type of with_context : OCIExtProcContext * + * amount - The number of bytes to allocate. + * Type of amount : size_t + * + * Output : + * Nothing + * + * Return : + * An untyped (opaque) Pointer to the allocated memory. + * + * Errors : + * A 0 return value should be treated as an error + * + * EXAMPLE + * text *ptr = (text *)OCIExtProcAllocCallMemory(wctx, 1024) + * + */ +#define OCIExtProcAllocCallMemory(with_context, amount) \ +ociepacm(with_context, (size_t)amount) + + + + +/* -------------------------- OCIExtProcRaiseExcp -------------------------- */ +/* OCIExtProcRaiseExcp + * Raise an Exception to PL/SQL. + * + * Calling this function signalls an exception back to PL/SQL. After a + * successful return from this function, the External Procedure must start + * its exit handling and return back to PL/SQL. Once an exception is + * signalled to PL/SQL, INOUT and OUT arguments, if any, are not processed + * at all. + * + * PARAMETERS + * Input : + * with_context - The with_context pointer that is passed to the C + * External Procedure. + * Type of with_context : OCIExtProcContext * + * errnum - Oracle Error number to signal to PL/SQL. errnum + * must be a positive number and in the range 1 to MAX_OEN + * Type of errnum : int + * Output : + * Nothing + * + * Return : + * OCIEXTPROC_SUCCESS - If the call was successful. + * OCIEXTPROC_ERROR - If the call failed. + * + */ +#define OCIExtProcRaiseExcp(with_context, errnum) \ +ocieperr(with_context, (int)errnum) + + + + + +/* ---------------------- OCIExtProcRaiseExcpWithMsg ---------------------- */ +/* OCIExtProcRaiseExcpWithMsg + * Raise an exception to PL/SQL. In addition, substitute the + * following error message string within the standard Oracle error + * message string. See note for OCIExtProcRaiseExcp + * + * PARAMETERS + * Input : + * with_context - The with_context pointer that is passed to the C + * External Procedure. + * Type of with_context : OCIExtProcContext * + * errnum - Oracle Error number to signal to PL/SQL. errnum + * must be a positive number and in the range 1 to MAX_OEN + * Type of errnum : int + * errmsg - The error message associated with the errnum. + * Type of errmsg : char * + * len - The length of the error message. 0 if errmsg is + * null terminated string. + * Type of len : size_t + * Output : + * Nothing + * + * Return : + * OCIEXTPROC_SUCCESS - If the call was successful. + * OCIEXTPROC_ERROR - If the call failed. + * + */ +#define OCIExtProcRaiseExcpWithMsg(with_context, errnum, errmsg, msglen) \ +ociepmsg(with_context, (int)errnum, errmsg, (size_t)msglen) + + + +/* --------------------------- OCIExtProcGetEnv --------------------------- */ +/* OCIExtProcGetEnv + * Get OCI Environment + * + * PARAMETERS + * Input : + * with_context - The with_context pointer that is passed to the C + * External Procedure. + * + * Output : + * envh - The OCI Environment handle. + * svch - The OCI Service handle. + * errh - The OCI Error handle. + * + * Return : + * OCI_SUCCESS - Successful completion of the function. + * OCI_ERROR - Error. + * + */ +#define OCIExtProcGetEnv(with_context, envh, svch, errh) \ +ociepgoe(with_context, envh, svch, errh) + + + +/* ------------------------ OCIInitializeStatementHandle ------------------- */ +/* OCIreateStatementHandle + * Initialize Statement Handle + * + * PARAMETERS + * Input : + * wctx - The + * cursorno - The cursor number for which we need to initialize + * the statement handle + * svch - The OCI Service handle. + * + * Output : + * stmthp - The OCI Statement handle. + * errh - The OCI Error handle. + * + * Return : + * OCI_SUCCESS - Successful completion of the function. + * OCI_ERROR - Error. + * + */ +#define OCIInitializeStatementHandle(wctx, cursorno, svch, stmthp, errh) \ +ociepish(wctx, cursor, svch, stmthp, errh) + + + + +/*--------------------------------------------------------------------------- + PRIVATE TYPES AND CONSTANTS + ---------------------------------------------------------------------------*/ + + +/*--------------------------------------------------------------------------- + PUBLIC FUNCTIONS + ---------------------------------------------------------------------------*/ + + +/*--------------------------------------------------------------------------- + PRIVATE FUNCTIONS + ---------------------------------------------------------------------------*/ + + + +void *ociepacm(OCIExtProcContext *with_context, size_t amount); + + + +size_t ocieperr(OCIExtProcContext *with_context, int error_number); + + + +size_t ociepmsg(OCIExtProcContext *with_context, int error_number, + oratext *error_message, size_t len ); + + + +sword ociepgoe(OCIExtProcContext *with_context, OCIEnv **envh, + OCISvcCtx **svch, OCIError **errh); + + +#endif /* OCIEXTP_ORACLE */ diff --git a/OCI/include/ocikpr.h b/OCI/include/ocikpr.h new file mode 100644 index 0000000..425d696 --- /dev/null +++ b/OCI/include/ocikpr.h @@ -0,0 +1,165 @@ +/* Copyright (c) 1991, 2005, Oracle. All rights reserved. */ +/* + NAME + ocikpr.h - header of K & R compilers + MODIFIED (MM/DD/YY) + mbastawa 09/16/05 - dbhygiene + porangas 12/04/00 - Forward merge bug#974710 to 9i + sgollapu 05/19/98 - Change text to OraText + dchatter 04/21/96 - + dchatter 11/10/95 - add ognfd() - get native fd + lchidamb 04/06/95 - drop maxdsz from obindps/odefinps + slari 04/07/95 - add opinit + dchatter 03/08/95 - osetpi and ogetpi + lchidamb 12/09/94 - add obindps() and odefinps() + dchatter 03/06/95 - merge changes from branch 1.1.720.2 + dchatter 11/14/94 - merge changes from branch 1.1.720.1 + dchatter 02/08/95 - olog call; drop onblon + dchatter 10/31/94 - new functions for non-blocking oci + rkooi2 11/27/92 - Changing datatypes (in comments) and return types + rkooi2 10/26/92 - More portability mods + rkooi2 10/18/92 - Changed to agree with oci.c + sjain 03/16/92 - Creation +*/ + +/* + * Declare the OCI functions. + * Prototype information is commented out. + * Use this header for non-ANSI C compilers. + * Note that you will need to include ocidfn.h in the .c files + * to get the definition for cda_def. + */ + +#ifndef OCIKPR +#define OCIKPR + +#include + +/* + * Oci BIND (Piecewise or with Skips) + */ +sword obindps( struct cda_def *cursor, ub1 opcode, OraText *sqlvar, + sb4 sqlvl, ub1 *pvctx, sb4 progvl, + sword ftype, sword scale, + sb2 *indp, ub2 *alen, ub2 *arcode, + sb4 pv_skip, sb4 ind_skip, sb4 alen_skip, sb4 rc_skip, + ub4 maxsiz, ub4 *cursiz, + OraText *fmt, sb4 fmtl, sword fmtt ); +sword obreak( struct cda_def *lda ); +sword ocan ( struct cda_def *cursor ); +sword oclose( struct cda_def *cursor ); +sword ocof ( struct cda_def *lda ); +sword ocom ( struct cda_def *lda ); +sword ocon ( struct cda_def *lda ); + + +/* + * Oci DEFINe (Piecewise or with Skips) + */ +sword odefinps( struct cda_def *cursor, ub1 opcode, sword pos,ub1 *bufctx, + sb4 bufl, sword ftype, sword scale, + sb2 *indp, OraText *fmt, sb4 fmtl, sword fmtt, + ub2 *rlen, ub2 *rcode, + sb4 pv_skip, sb4 ind_skip, sb4 alen_skip, sb4 rc_skip ); +sword odescr( struct cda_def *cursor, sword pos, sb4 *dbsize, + sb2 *dbtype, sb1 *cbuf, sb4 *cbufl, sb4 *dsize, + sb2 *prec, sb2 *scale, sb2 *nullok ); +sword odessp( struct cda_def *cursor, OraText *objnam, size_t onlen, + ub1 *rsv1, size_t rsv1ln, ub1 *rsv2, size_t rsv2ln, + ub2 *ovrld, ub2 *pos, ub2 *level, OraText **argnam, + ub2 *arnlen, ub2 *dtype, ub1 *defsup, ub1* mode, + ub4 *dtsiz, sb2 *prec, sb2 *scale, ub1 *radix, + ub4 *spare, ub4 *arrsiz ); +sword oerhms( struct cda_def *lda, sb2 rcode, OraText *buf, + sword bufsiz ); +sword oermsg( sb2 rcode, OraText *buf ); +sword oexec ( struct cda_def *cursor ); +sword oexfet( struct cda_def *cursor, ub4 nrows, + sword cancel, sword exact ); +sword oexn ( struct cda_def *cursor, sword iters, sword rowoff ); +sword ofen ( struct cda_def *cursor, sword nrows ); +sword ofetch( struct cda_def *cursor ); +sword oflng ( struct cda_def *cursor, sword pos, ub1 *buf, + sb4 bufl, sword dtype, ub4 *retl, sb4 offset ); +sword ogetpi( struct cda_def *cursor, ub1 *piecep, void **ctxpp, + ub4 *iterp, ub4 *indexp ); +sword opinit( ub4 mode ); +sword olog ( struct cda_def *lda, ub1 *hst, + OraText *uid, sword uidl, + OraText *psw, sword pswl, + OraText *conn, sword connl, + ub4 mode ); +sword ologof( struct cda_def *lda ); +sword oopen ( struct cda_def *cursor, struct cda_def *lda, + OraText *dbn, sword dbnl, sword arsize, + OraText *uid, sword uidl ); +sword oopt ( struct cda_def *cursor, sword rbopt, sword waitopt ); +sword oparse( struct cda_def *cursor, OraText *sqlstm, sb4 sqllen, + sword defflg, ub4 lngflg ); +sword orol ( struct cda_def *lda ); +sword osetpi( struct cda_def *cursor, ub1 piece, void *bufp, + ub4 *lenp ); +void sqlld2 ( struct cda_def *lda, OraText *cname, sb4 *cnlen ); +void sqllda ( struct cda_def *lda ); + +/* non-blocking functions */ +sword onbset( struct cda_def *lda ); +sword onbtst( struct cda_def *lda ); +sword onbclr( struct cda_def *lda ); +sword ognfd ( struct cda_def *lda, void *fdp ); + + + +/* + * OBSOLETE FUNCTIONS + */ + +/* + * OBSOLETE BIND CALLS-- use obindps() + */ +sword obndra( struct cda_def *cursor, OraText *sqlvar, sword sqlvl, + ub1 *progv, sword progvl, sword ftype, sword scale, + sb2 *indp, ub2 *alen, ub2 *arcode, ub4 maxsiz, + ub4 *cursiz, OraText *fmt, sword fmtl, sword fmtt ); +sword obndrn( struct cda_def *cursor, sword sqlvn, ub1 *progv, + sword progvl, sword ftype, sword scale, sb2 *indp, + OraText *fmt, sword fmtl, sword fmtt ); +sword obndrv( struct cda_def *cursor, OraText *sqlvar, sword sqlvl, + ub1 *progv, sword progvl, sword ftype, sword scale, + sb2 *indp, OraText *fmt, sword fmtl, sword fmtt ); + +/* + * OBSOLETE DEFINE CALLS-- use odefinps() + */ +sword odefin( struct cda_def *cursor, sword pos, ub1 *buf, + sword bufl, sword ftype, sword scale, sb2 *indp, + OraText *fmt, sword fmtl, sword fmtt, ub2 *rlen, + ub2 *rcode ); + + +/* older calls ; preferred equivalent calls above */ +sword odsc ( struct cda_def *cursor, sword pos, sb2 *dbsize, + sb2 *fsize, sb2 *rcode, sb2 *dtype, sb1 *buf, + sb2 *bufl, sb2 *dsize ); +sword oname ( struct cda_def *cursor, sword pos, sb1 *tbuf, + sb2 *tbufl, sb1 *buf, sb2 *bufl ); +sword olon ( struct cda_def *lda, OraText *uid, sword uidl, + OraText *pswd, sword pswdl, sword audit ); +sword orlon ( struct cda_def *lda, ub1 *hda, OraText *uid, + sword uidl, OraText *pswd, sword pswdl, sword audit ); +sword osql3 ( struct cda_def *cda, OraText *sqlstm, sword sqllen ); + + + + + + + +#endif /* OCIKPR */ + + + + + + + diff --git a/OCI/include/ocilib.h b/OCI/include/ocilib.h new file mode 100644 index 0000000..6275f54 --- /dev/null +++ b/OCI/include/ocilib.h @@ -0,0 +1,98 @@ +/*===================================================================================================================== + Copyright(c) 2012 ORIGIN. + Unpublished - All rights reserved +======================================================================================================================= +File description: + + Filename: ocilib.h + Module : OCI + + This Header file of OCI library Package. + +======================================================================================================================= +Date Name Description of Change +1-Feb-2015 Ray Initialize creation +$HISTORY$ +=====================================================================================================================*/ +#include +#include +#include +#include +#include +//#include + +#define OCI_FAIL 1 +#define OCI_OK 0 + +#ifdef __cplusplus +extern "C" +{ +#endif + /** + * ݿ. + * @param username - û + * @param password - + * @param dbname - ݿSID + * @return - OCI_OK or error code + * + * ORACLE ݿװ + */ + extern int ConnServer(char* username, char* password, char* dbname); + + + /** + * ִSQL. + * @param SQL - SQL + * @return - OCI_OK or error code + * + * ORACLE ݿװ + */ + extern int ExecuteSQLNoInputParam(char* SQL); + + /** + * ִSQL. + * @param SQL - SQL + * @param inputValueCount - + * @param inputValue - ֵ + * @return - OCI_OK or error code + * + * ORACLE ݿװ + */ + extern int ExecuteSQL(char* SQL, int inputValueCount, char** inputValue); + + /** + * IJѯSQL. + * @param SQL - SQL + * @param outputColumn - е + * @param outputValueCount - е + * @param outputValue - + * @return - OCI_OK or error code + * + * ORACLE ݿװ + */ + extern int QuerySQLNoInputParam(char* SQL, int* outputColumn, int* outputValueCount, char**** outputValue); + + /** + * IJѯSQL. + * @param SQL - SQL + * @param inputValueCount - + * @param inputValue - ֵ + * @param outputColumn - е + * @param outputValueCount - е + * @param outputValue - + * @return - OCI_OK or error code + * + * ORACLE ݿװ + */ + extern int QuerySQL(char* SQL, int inputValueCount, char** inputValue, int* outputColumn, int* outputValueCount, char**** outputValue); + + /** + * Ͽݿ. + * + * ORACLE ݿװ + */ + extern void DisConnServer(); + +#ifdef __cplusplus +} +#endif diff --git a/OCI/include/ocixml.h b/OCI/include/ocixml.h new file mode 100644 index 0000000..1c30188 --- /dev/null +++ b/OCI/include/ocixml.h @@ -0,0 +1,188 @@ +/* Copyright (c) 2003, 2009, Oracle and/or its affiliates. +All rights reserved. */ + +/* + NAME + ocixml.h - OCIXMLType functions + + DESCRIPTION + This file contains all OCIXMLType functions defined in ocixml.c + + + ****************************IMPORTANT*********************************** + *** If you change the signatures of any fucntions in this file, make sure + *** to make same changes to Windows OSD file ociclnt.c. Otherwise, users + *** of OCI instant client like ODP.NET will have build issues or crashes + ****************************IMPORTANT*********************************** + + PUBLIC FUNCTION(S) + OCIXMLTypeNew() + OCIXMLTypeCreateFromSrc() + OCIXMLTypeCreateFromSrcWithSchema() + OCIXMLTypeTransform() + OCIXMLTypeExtract() + OCIXMLTypeIsSchemaBased() + OCIXMLTypeValidate() + OCIXMLTypeExists() + OCIXMLTypeGetDOM() + OCIXMLTypeGetFromDOM() + OCIDOMFree() + OCIXMLSEMutexAcq() + OCIXMLSEMutexRel() + OCIXMLUpdateNodeValues() + + INTERNAL FUNCTION(S) + + EXAMPLES + + NOTES + + MODIFIED (MM/DD/YY) + spetride 03/02/09 - add isdoc to OCIXMLTypeCreateFromSrc* + bsthanik 01/17/07 - 5753599: wrappers for service mutex acq/rel + bkhaladk 05/10/06 - add setpicklepref + nitgupta 01/30/06 - add signatures for OCIBinXMl* + dmukhin 06/16/05 - ANSI prototypes; miscellaneous cleanup + dmukhin 06/14/05 - ANSI prototypes; miscellaneous cleanup + ataracha 12/04/03 - convert public oci api to ansi + ataracha 01/21/03 - ataracha_uni_capi_cleanup + ataracha 01/08/03 - Creation + +*/ +#ifndef OCI_ORACLE +# include +#endif + +#ifndef XML0_ORACLE +# include +#endif + +#ifndef OCIXML_ORACLE +# define OCIXML_ORACLE + +/*--------------------------------------------------------------------------- + PUBLIC TYPES AND CONSTANTS + ---------------------------------------------------------------------------*/ + +/* parameters for OCIXMLUpdateNodeValues */ +struct OCIXMLunv +{ + void * xpth_OCIXMLunv; /* xpath expression */ + void * val_OCIXMLunv; /* value - string literal or xmltype */ + ub4 xpthL_OCIXMLunv; /* length of xpath expression string */ + ub4 valL_OCIXMLunv; /* length of value string */ + ub1 tp_OCIXMLunv; /* type of value - xmltype of string */ + +#define OCIXMLUNV_XTP 0x00 /* param is xmltype */ +#define OCIXMLUNV_STP 0x01 /* param is string literal */ +#define OCIXMLUNV_STM 0x02 /* param is a stream (kghsstream *) */ +#define OCIXMLUNV_CLOB 0x03 /* param is a CLOB locator (kolblc *) */ +#define OCIXMLUNV_BLOB 0x04 /* param is a BLOB locator (kolblc *) */ +}; +typedef struct OCIXMLunv OCIXMLunv; + +/*--------------------------------------------------------------------------- + PRIVATE TYPES AND CONSTANTS + ---------------------------------------------------------------------------*/ + + +/*--------------------------------------------------------------------------- + EXPORT FUNCTIONS + ---------------------------------------------------------------------------*/ +sword OCIXMLTypeNew(OCISvcCtx *svchp, OCIError *errhp, OCIDuration dur, + OraText *elname, ub4 elname_Len, + OraText *schemaURL, ub4 schemaURL_Len, + OCIXMLType **retInstance); + +sword OCIXMLTypeCreateFromSrc(OCISvcCtx *svchp, OCIError *errhp, + OCIDuration dur, ub1 src_type, void *src_ptr, + sb4 ind, OCIXMLType **retInstance, ub4 csid); +sword OCIXMLTypeCreateFromSrcInt(OCISvcCtx *svchp, OCIError *errhp, + OCIDuration dur, ub1 src_type, void *src_ptr, + sb4 ind, OCIXMLType **retInstance, ub4 csid, + boolean isdoc); + +sword OCIXMLTypeCreateFromSrcWithSchema(OCISvcCtx *svchp, OCIError *errhp, + OCIDuration dur, ub1 src_type, void *src_ptr, + sb4 ind, OraText *schemaURL, ub4 schemaURL_Len, + boolean wellformed, boolean valid, + OCIXMLType **retInstance, ub4 csid); +sword OCIXMLTypeCreateFromSrcWithSchemaInt(OCISvcCtx *svchp, OCIError *errhp, + OCIDuration dur, ub1 src_type, void *src_ptr, + sb4 ind, OraText *schemaURL, ub4 schemaURL_Len, + boolean wellformed, boolean valid, + OCIXMLType **retInstance, ub4 csid, + boolean isdoc); + +sword OCIXMLTypeExtract(OCIError *errhp, + OCIXMLType *doc, OCIDuration dur, + OraText *xpathexpr, ub4 xpathexpr_Len, + OraText *nsmap, ub4 nsmap_Len, + OCIXMLType **retDoc); + +sword OCIXMLTypeTransform(OCIError *errhp, OCIDuration dur, + OCIXMLType *doc, OCIXMLType *xsldoc, + OCIXMLType **retDoc); + +/* Note: xpathexpr is case sensitive */ +sword OCIXMLTypeExists(OCIError *errhp, OCIXMLType *doc, + OraText *xpathexpr, ub4 xpathexpr_Len, + OraText *nsmap, ub4 nsmap_Len, + boolean *retval); + +sword OCIXMLTypeIsSchemaBased(OCIError *errhp, + OCIXMLType *doc, boolean *retval); + +sword OCIXMLTypeIsFragment(OCIError *errhp, OCIXMLType *doc, boolean *retval); + +sword OCIXMLTypeGetSchema(OCIError *errhp, OCIXMLType *doc, + OCIXMLType **schemadoc, + OraText **schemaURL, ub4 *schemaURL_Len, + OraText **rootelem, ub4 *rootelem_Len); + +sword OCIXMLTypeValidate(OCIError *errhp, OCIXMLType *doc, + OraText *schemaURL, ub4 schemaURL_Len, boolean *retval); + +sword OCIXMLTypeGetDOM(OCIError *errhp, OCIXMLType *doc, OCIDuration dur, + OCIDOMDocument **retDom); + +sword OCIXMLTypeGetFromDOM(OCIError *errhp, OCIDOMDocument *domdoc, + OCIXMLType **retXMLType); + +sword OCIXMLTypeGetNS(OCIError *errhp, OCIXMLType *domdoc, + OraText **ns, ub4 *ns_len); + +sword OCIDOMFree(OCIError *errhp, OCIDOMDocument *domdoc); + +sword OCIBinXmlCreateReposCtxFromConn(OCIEnv *env, OCISvcCtx *svcctx, + OCIError *err, OCIBinXmlReposCtx **ctx); +sword OCIBinXmlCreateReposCtxFromCPool(OCIEnv *env, OCICPool *cpool, + OCIError *err, OCIBinXmlReposCtx **ctx); +sword OCIBinXmlSetReposCtxForConn(OCISvcCtx *dataconn, + OCIBinXmlReposCtx *reposctx); + +#define OCIXML_FORMATTYPE_TEXT 0 +#define OCIXML_FORMATTYPE_BINXML 1 + +sword OCIBinXmlSetFormatPref(xmldocnode *doc, ub4 format); + +/* OCI Wrapper to acquire mutex associated with service handle and + * env handle + */ +sword OCIXMLSEMutexAcq(OCISvcCtx *svchp, OCIError *errhp); + +/* release wrapper corresponding to OCIXMLSEMutexAcq */ +sword OCIXMLSEMutexRel(OCISvcCtx *svchp, OCIError *errhp); + +/* acquires OCI svc and env mutexes, updates values of nodes pointed to by + * given XPATH locations, and releases mutexes. + */ +sword OCIXMLUpdateNodeValues(OCISvcCtx *svchp, OCIError *errhp, OCIXMLType + **docp, struct OCIXMLunv *values, ub4 numvalues, oratext *nsmap, + ub4 nsmapl); +/*--------------------------------------------------------------------------- + INTERNAL FUNCTIONS + ---------------------------------------------------------------------------*/ + + +#endif /* OCIXML_ORACLE */ diff --git a/OCI/include/ocixmldb.h b/OCI/include/ocixmldb.h new file mode 100644 index 0000000..95ece13 --- /dev/null +++ b/OCI/include/ocixmldb.h @@ -0,0 +1,141 @@ +/* Copyright (c) 2003, 2009, Oracle and/or its affiliates. +All rights reserved. */ + +/* + NAME + ocixmldb.h - XDB public functions + + DESCRIPTION + This file contains XDB specific public functions required for DOM C-API. + + RELATED DOCUMENTS + + + EXPORT FUNCTION(S) + struct xmlctx *OCIXmlDbInitXmlCtx(OCIEnv *, OCISvcCtx *, OCIError *, + ocixmldbparam *params, int num_params); + + void OCIXmlDbFreeXmlCtx(struct xmlctx *xctx); + + + ------------------------------------------------------------------------ + EXAMPLES + + NOTES + + MODIFIED (MM/DD/YY) + ataracha 12/11/03 - remove redundant definitions + ataracha 05/28/03 - change names + ataracha 02/18/03 - add oratypes, remove XMLERR_* + imacky 02/01/03 - remove xml.h; xdbs fix + ataracha 01/24/03 - use "struct xmlctx" instead of xmlctx + imacky 01/28/03 - fix XMLERR defs + ataracha 01/21/03 - ataracha_uni_capi_cleanup + ataracha 01/09/03 - Creation + +*/ + +#ifndef ORATYPES +#include +#endif + +#ifndef OCI_ORACLE +# include +#endif + +#ifndef OCIXMLDB_ORACLE +# define OCIXMLDB_ORACLE + + +/*--------------------------------------------------------------------------- + PUBLIC TYPES AND CONSTANTS + ---------------------------------------------------------------------------*/ + +#ifndef XMLCTX_DEFINED +# define XMLCTX_DEFINED +/* DATATYPE xmlctx - XML top-level context +*/ +struct xmlctx; typedef struct xmlctx xmlctx; +#endif + +typedef enum +{ + XCTXINIT_OCIDUR = 1, + XCTXINIT_ERRHDL = 2 +} ocixmldbpname; + +typedef struct ocixmldbparam +{ + ocixmldbpname name_ocixmldbparam; + void *value_ocixmldbparam; +} ocixmldbparam; + +#define NUM_OCIXMLDBPARAMS 2 + +/*--------------------------------------------------------------------------- + PRIVATE TYPES AND CONSTANTS + ---------------------------------------------------------------------------*/ + + +/*--------------------------------------------------------------------------- + EXPORT FUNCTIONS + ---------------------------------------------------------------------------*/ +/***************************************************************************** + DESCRIPTION + +-----------------------------OCIXmlDbInitXmlCtx--------------------------------- +Name +OCIXmlDbInitXmlCtx +Purpose +To get a xmlctx structure initialized with error-handler and XDB callbacks. +Syntax +struct xmlctx *OCIXmlDbInitXmlCtx (OCIEnv *envhp, + OCISvcCtx *svchp, + OCIError *err, + params_ocixmldb *params, + int num_params); +Parameters +envhp (IN) - The OCI environment handle +svchp (IN) - The OCI service handle +errhp (IN) - The OCI error handle +params (IN)- This contains the following optional parameters : + (a) OCIDuration dur (IN - The OCI Duration (Default: OCI_DURATION_SESSION) + (b) void (*err_handler) (sword, (const oratext *) (IN) - + Pointer to the error handling function (Default: null) +num_params (IN) - Number of parameters to be read from parameter params. + If the value of num_params exceeds the size of array + "params", unexpected behavior will result. + +Returns +A pointer to xmlctx structure, with xdb context, error handler and callbacks +populated with appropriate values. This is later used for all API calls. NULL +if no database connection available. + +-----------------------------OCIXmlDbFreeXmlCtx---------------------------- +Name +OCIXmlDbFreeXmlCtx +Pupose +To free any allocations done during OCIXmlDbInitXmlCtx. +Syntax +void OCIXmlDbFreeXmlCtx (struct xmlctx *xctx) +Parameters +xctx (IN) - The xmlctx to terminate +Returns +- +******************************************************************************/ + +struct xmlctx *OCIXmlDbInitXmlCtx(OCIEnv *, OCISvcCtx *, OCIError *, + ocixmldbparam *, int); + +void OCIXmlDbFreeXmlCtx(struct xmlctx *xctx); +sword OCIXmlDbStreamFromXMLType(OCIError *errhp, void **stream, + OCIXMLType *doc, ub4 mode); +sword OCIXmlDbStreamRead(OCIError *errhp, void *stream, + void *bufp, sb8 *len, ub4 mode); +sword OCIXmlDbStreamClose(OCIError *errhp, void *stream); +/*--------------------------------------------------------------------------- + INTERNAL FUNCTIONS + ---------------------------------------------------------------------------*/ + + +#endif /* OCIXMLDB_ORACLE */ diff --git a/OCI/include/ocixstream.h b/OCI/include/ocixstream.h new file mode 100644 index 0000000..fc9a641 --- /dev/null +++ b/OCI/include/ocixstream.h @@ -0,0 +1,1899 @@ +/* Copyright (c) 2006, 2009, Oracle and/or its affiliates. +All rights reserved. */ + +/* + NAME + ocixstreams.h - OCI X-Stream APIs + + DESCRIPTION + OCI APIs for X-Stream + + RELATED DOCUMENTS + + EXPORT FUNCTION(S) + + INTERNAL FUNCTION(S) + + EXAMPLES + + NOTES + + MODIFIED (MM/DD/YY) + thoang 05/08/09 - Add OCILCR_NEW_ONLY_MODE + praghuna 05/11/09 - removed 'TODO' comments + thoang 02/15/09 - Change lob_column_* to chunk_column_* + thoang 01/27/09 - 8216105 - add OLD/NEW column parms to OCILCRHeaderGet + rihuang 01/05/09 - Add OCI_LCR_ATTR_TRACKING_LABEL + tianli 11/28/08 - add DDL flags + tianli 11/20/08 - add OCILCRAttribute methods + thoang 11/20/08 - Define OCI_LCR_MAX_TXID_LEN + tianli 11/07/08 - add edition + thoang 11/10/08 - change return type to sword for consistency + thoang 10/16/08 - remove commit position arg + tianli 08/26/08 - rename client_name in XStreamIn attach call + thoang 06/30/08 - Support XStream APIs using two callbacks. + praghuna 05/14/08 - charset id is ub2, OCILcrGetRowStmtWithBindVar + thoang 06/02/08 - Define reserved attach mode for internal clients + elu 05/08/08 - add pos functions + thoang 04/29/08 - API changes + jinwu 04/28/08 - add OCILcrGetExtraAttributes + elu 04/14/08 - add OCI_LCR_MAX_POSITION_LEN + juyuan 03/27/08 - add flag for Set/GetHeader and Set/GetColumnInfo + thoang 02/25/08 - Add GetNextChunk and SetNextChunk + rihuang 03/24/08 - Signature change for OCILcrNew + elu 03/05/08 - add lcr id + praghuna 02/26/08 - Added OCILcrGetRowStmt + thoang 01/25/08 - Add wm_time parameter to XApply APIs + thoang 12/28/07 - Add mode parameter to XApplyDetach + thoang 11/07/07 - Change extapp apis to return ub1[] watermark + juyuan 05/23/07 - XStream In + thoang 11/13/06 - Add XStream Out methods + thoang 11/13/06 - Add LCR getter methods + nshodhan 05/12/06 - streams OCI APIs + nshodhan 05/12/06 - Creation + +*/ + +#ifndef OCIXSTREAM_ORACLE +# define OCIXSTREAM_ORACLE + +#ifndef ORATYPES +# include +#endif + +#ifndef OCI_ORACLE +# include +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +/*--------------------------------------------------------------------------- + PUBLIC TYPES AND CONSTANTS + ---------------------------------------------------------------------------*/ +/* LCR Types -- must match with values defined in kngo.h */ +#define OCI_LCR_XROW (3) /* External Row LCR */ +#define OCI_LCR_XDDL (4) /* External DDL LCR */ + +/* DML Command Types -- must match with values defined in kngl.h */ +#define OCI_LCR_ROW_CMD_INSERT "INSERT" +#define OCI_LCR_ROW_CMD_DELETE "DELETE" +#define OCI_LCR_ROW_CMD_UPDATE "UPDATE" +#define OCI_LCR_ROW_CMD_COMMIT "COMMIT" +#define OCI_LCR_ROW_CMD_LOB_WRITE "LOB WRITE" +#define OCI_LCR_ROW_CMD_LOB_TRIM "LOB TRIM" +#define OCI_LCR_ROW_CMD_LOB_ERASE "LOB ERASE" + +/* LCR Extra Attribute Name -- must match with values defined in knll.h */ +#define OCI_LCR_ATTR_THREAD_NO "THREAD#" +#define OCI_LCR_ATTR_ROW_ID "ROW_ID" +#define OCI_LCR_ATTR_SESSION_NO "SESSION#" +#define OCI_LCR_ATTR_SERIAL_NO "SERIAL#" +#define OCI_LCR_ATTR_USERNAME "USERNAME" +#define OCI_LCR_ATTR_TX_NAME "TX_NAME" + +/* below are non first class LCR field specific */ +#define OCI_LCR_ATTR_EDITION_NAME "EDITION_NAME" +#define OCI_LCR_ATTR_MESSAGE_TRACKING_LABEL "MESSAGE_TRACKING_LABEL" + +/* the maximum total number of attributes, total of extra attributes + * plus non first class LCR field. */ +#define OCI_LCR_MAX_ATTRIBUTES 8 + +/* Row LCR column value types used in OCILCRRowColumnInfoGet/Set functions. */ +#define OCI_LCR_ROW_COLVAL_OLD 0 /* OLD columns */ +#define OCI_LCR_ROW_COLVAL_NEW 1 /* NEW columns */ + +/* maximum length for position */ +#define OCI_LCR_MAX_POSITION_LEN 64 + +/* maximum length for txid */ +#define OCI_LCR_MAX_TXID_LEN 128 + +/* Valid column flags used in OCILCRRowColumnInfoSet, OCILCRRowColumnInfoGet, + * OCILCRLobInfoSet, OCILCRLobInfoGet, OCIXStreamOutChunkReceive, + * OCIXStreamInChunkSend calls. + */ +#define OCI_LCR_COLUMN_LOB_DATA (0x00000001) /* col contains lob data */ +#define OCI_LCR_COLUMN_LONG_DATA (0x00000002) /* col contains long data*/ +#define OCI_LCR_COLUMN_EMPTY_LOB (0x00000004) /* col has an empty lob */ +#define OCI_LCR_COLUMN_LAST_CHUNK (0x00000008) /* last chunk of current col*/ +#define OCI_LCR_COLUMN_AL16UTF16 (0x00000010) /* col is in AL16UTF16 fmt */ +#define OCI_LCR_COLUMN_NCLOB (0x00000020) /* col has NCLOB data */ +#define OCI_LCR_COLUMN_XML_DATA (0x00000040) /* col contains xml data */ +#define OCI_LCR_COLUMN_XML_DIFF (0x00000080)/* col contains xmldiff data */ +#define OCI_LCR_COLUMN_ENCRYPTED (0x00000100) /* col is encrypted */ + +/* OCI_LCR_COLUMN_UPDATED is set only for the modified columns in the NEW + * column list of an update LCR. + */ +#define OCI_LCR_COLUMN_UPDATED (0x00000200) /* col is updated */ + +/* Valid bit values for flag parameter in the following APIs: + * - OCIXStreamOutChunkReceive & OCIXStreamOutLCRReceive + * - OCIXStreamInChunkSend & OCIXStreamInLCRSend + */ +#define OCI_XSTREAM_MORE_ROW_DATA (0x00000001) /* LCR contains more data */ + +/* Valid mode flag for OCILCRHeaderGet and OCILCRRowColumnInfoGet functions */ +#define OCILCR_NEW_ONLY_MODE (0x0001) /* NEW columns only -- dont */ + /* include OLD columns */ + +/*--------------------------------------------------------------------------- + PRIVATE TYPES AND CONSTANTS + ---------------------------------------------------------------------------*/ + + +/*--------------------------------------------------------------------------- + EXPORT FUNCTIONS + ---------------------------------------------------------------------------*/ +/* +------------------------------------------------------------------------------= +NAME + OCILCRNew - OCI LCR NEW +DESCRIPTION + Create a new Streams LCR for the user specified duration and type +PARAMETERS + svchp (IN) - OCI service context + errhp (IN) - OCI Error Handle + duration (IN) - allocation duration for LCR memory + lcrtype (IN) - LCR type (OCI_LCR_XROW / OCI_LCR_XDDL) + lcrp (IN/OUT) - Streams LCR. (*lcrp must be initialized to null.) + mode (IN) - mode +NOTES + - memory will be based on the duration specified by the user + - For now, specify OCI_DEFAULT for mode +------------------------------------------------------------------------------= +*/ +sword OCILCRNew(OCISvcCtx *svchp, + OCIError *errhp, + OCIDuration duration, + ub1 lcrtype, + void **lcrp, + ub4 mode); + +/* +------------------------------------------------------------------------------= +NAME + OCILCRFree - OCI LCR FREE +DESCRIPTION + Free Streams LCR specified by the user +PARAMETERS + svchp (IN) - OCI service context + errhp (IN) - OCI Error Handle + lcrp (IN/OUT) - Streams LCR + mode (IN) - mode +NOTES + - For now, specify OCI_DEFAULT for mode +------------------------------------------------------------------------------= +*/ +sword OCILCRFree(OCISvcCtx *svchp, + OCIError *errhp, + void *lcrp, + ub4 mode); + + +/* +------------------------------------------------------------------------------= +NAME + OCILCRHeaderSet - OCI LCR Set Header +DESCRIPTION + Initialize elements of Streams LCR's header +PARAMETERS + svchp (IN) - OCI service context + errhp (IN) - OCI Error Handle + src_db_name (IN) - Pointer to Canonicalized source database name. + Must be non-NULL. + src_db_name_len (IN) - Length of source database name in bytes + excluding NULL terminator. Should follow Oracle + naming conventions and size limitations. + cmd_type (IN) - For ROW LCRs: OCI_LCR_ROW_CMD_XXXXXXX + For DDL LCRs: One of the command types + corresponding to OCI Reference manual + cmd_type_len (IN) - Length of cmd_type. + owner (IN) - Canonicalized table owner name. Not required + for COMMIT LCR. + owner_len (IN) - Length of owner name in bytes excluding the + NULL terminator. Should follow Oracle naming + conventions and size limitations. + oname (IN) - Canonicalized table name. Not required for + COMIT LCR. + oname_len (IN) - Length of table name in bytes excluding the + NULL terminator. Should follow Oracle naming + conventions and size limitations. + tag (IN) - A binary tag that enables tracking of the LCR. + For example, this tag can be used to determine + the original source database of the DML + statement if apply forwarding is used. + tag_len (IN) - Number of bytes in the tag. Cannot exceed 2000 + bytes + txid (IN) - Transaction ID. + txid_len (IN) - Length of transaction id in bytes excluding the + NULL terminator. Should not exceeed + OCI_LCR_MAX_TXID_LEN bytes. + src_time (IN) - The time when the change was generated at the + source database. + position (IN) - position for LCR. Must be byte-comparable. + position_len (IN) - Length of position. Must be non-zero. + flag (IN) - LCR flag. + lcrp (IN/OUT) - Streams LCR + mode (IN) - mode +NOTES + - For now, specify OCI_DEFAULT for mode + - This function clears the current contents of the input LCR before + setting the header to the new values. +------------------------------------------------------------------------------= +*/ +sword OCILCRHeaderSet(OCISvcCtx *svchp, + OCIError *errhp, + oratext *src_db_name, + ub2 src_db_name_len, + oratext *cmd_type, + ub2 cmd_type_len, + oratext *owner, + ub2 owner_len, + oratext *oname, + ub2 oname_len, + ub1 *tag, + ub2 tag_len, + oratext *txid, + ub2 txid_len, + OCIDate *src_time, + ub1 *position, + ub2 position_len, + oraub8 flag, + void *lcrp, + ub4 mode); + +/* +------------------------------------------------------------------------------= +NAME + OCILCRHeaderGet - OCI LCR Get Header +DESCRIPTION + Get header information from Streams LCR +PARAMETERS + svchp (IN) - OCI service context + errhp (IN) - OCI Error Handle + src_db_name (OUT) - Pointer to Canonicalized source database name. + Optional, if src_db_name is specified then + must specify src_db_name_len as well. + src_db_name_len (OUT) - Length of source database name in bytes + excluding NULL terminator. + Optional, if specified src_db_name_len then + must specify src_db_name as well. + cmd_type (OUT) - Command type. Must be non-null if + cmd_type_len is non-null. Must be null if + cmd_type_len is NULL. + cmd_type_len (OUT) - Length of cmd_type. Optional. + owner (OUT) - Canonicalized table owner name. + Optional, if owner is specified then + must specify owner_len as well. + owner_len (OUT) - Length of owner name in bytes excluding the + NULL terminator. + Optional, if owner_len is specified then + must specify owner as well. + oname (OUT) - Canonicalized table name. + Optional, if oname is specified then + must specify oname_len as well. + oname_len (OUT) - Length of table name in bytes excluding the + NULL terminator. + Optional, if oname_len is specified then + must specify oname as well. + tag (OUT) - A binary tag that enables tracking of the LCR. + For example, this tag can be used to determine + the original source database of the + DML statement if apply forwarding is used. + Optional, if tag is specified then + must specify tag_len as well. + tag_len (OUT) - Number of bytes in the tag. + Optional, if tag_len is specified then + must specify tag as well. + txid (OUT) - Transaction ID. + Optional, if txid is specified then + must specify txid_len as well. + txid_len (OUT) - Length of transaction id in bytes excluding + the NULL terminator. + Optional, if txid_len is specified then + must specify txid as well. + src_time (OUT) - The time when the change was generated at the + source database. Optional. + old_columns (OUT) - Number of columns in the OLD column list. + Return 0 if input lcr is DDL LCR. Optional. + new_columns (OUT) - Number of columns present in either + the OLD or NEW column list. + Return 0 if input lcr is DDL LCR. Optional. + See NOTES below for the special mode supported + by this function. + position (OUT) - LCR position. Optional. + position_len (OUT) - Length of position. Must be non-null if + position is non-null. Must be null if + position is null. + flag (OUT) - LCR flag. Optional. + lcrp (IN) - Streams LCR + mode (IN) - mode (see NOTES) +NOTES + - Parameter src_time is optional. If specified the appropriate return + structure must be pre-allocated before calling OCILCRHeaderGet. + - The return values for src_db_name, cmd_type, owner, oname, tag, txid and + position are shallow-copied (i.e., they point directly into the LCR + structure). + - Valid mode flags: + - OCILCR_NEW_ONLY_MODE: if this mode is specified then the new_columns + returned is the count of the columns in the NEW column list only. + Otherwise, the new_columns returned is the number of distinct + columns present in either the NEW or the OLD column list of the given + ROW LCR. +------------------------------------------------------------------------------= +*/ + +sword OCILCRHeaderGet(OCISvcCtx *svchp, + OCIError *errhp, + oratext **src_db_name, + ub2 *src_db_name_len, + oratext **cmd_type, + ub2 *cmd_type_len, + oratext **owner, + ub2 *owner_len, + oratext **oname, + ub2 *oname_len, + ub1 **tag, + ub2 *tag_len, + oratext **txid, + ub2 *txid_len, + OCIDate *src_time, + ub2 *old_columns, + ub2 *new_columns, + ub1 **position, + ub2 *position_len, + oraub8 *flag, + void *lcrp, + ub4 mode); + +/* +------------------------------------------------------------------------------= +NAME + OCILCRRowColumnInfoSet - OCI LCR ROW SET COLUMN INFO +DESCRIPTION + Populates column information as specified by the user. +PARAMETERS + svchp (IN) - OCI service context + errhp (IN) - OCI Error Handle + column_value_type (IN) - ROW LCR column value type: + - OCI_LCR_ROW_COLVAL_OLD + - OCI_LCR_ROW_COLVAL_NEW + num_columns (IN) - Number of columns to be populated + column_names (IN) - Pointer to an array of column names. Column + names must be canonicalized. Column names should + follow Oracle naming conventions + column_name_lens (IN) - Pointer to an array of column name lengths + in bytes, excluding the NULL terminator. + column_dtyp (IN) - Pointer to an array of column datatypes. + column_valuesp (IN) - Pointer to an array of column data values. + column_indp (IN) - Pointer to an indicator array. For all datatypes, + this is a pointer to an array of OCIInd values + (OCI_IND_NULL/OCI_IND_NOTNULL). + column_alensp (IN) - Pointer to an array of actual column lengths in + bytes. + column_csetfp (IN) - Pointer to an array of character set forms for + the columns. The default form is SQLCS_IMPLICIT. + Setting this attribute will cause the database or + national character set to be used on the client + side. Set this attribute to SQLCS_NCHAR for the + national character set or SQLCS_IMPLICIT for the + database character set. + Pass 0 for non-character columns. + column_flags (IN) - Pointer to an array of column flags. + Possible bit values are OCI_LCR_COLUMN_* flags + listed above. + column_csid (IN) - Pointer to an array of column character set id. + The character set id is only required for + XMLType column; otherwise, the csid is ignored. + row_lcrp (IN/OUT)- Streams Row LCR pointer + mode (IN) - mode +NOTES + - For now, specify OCI_DEFAULT for mode +------------------------------------------------------------------------------= +*/ +sword OCILCRRowColumnInfoSet(OCISvcCtx *svchp, + OCIError *errhp, + ub2 column_value_type, + ub2 num_columns, + oratext **column_names, + ub2 *column_name_lens, + ub2 *column_dtyp, + void **column_valuesp, + OCIInd *column_indp, + ub2 *column_alensp, + ub1 *column_csetfp, + oraub8 *column_flags, + ub2 *column_csid, + void *row_lcrp, + ub4 mode); + +/* +------------------------------------------------------------------------------= +NAME + OCILCRRowColumnInfoGet - OCI LCR ROW GET COLUMN INFO +DESCRIPTION + Returns column information as requested by the user. +PARAMETERS + svchp (IN) - OCI service context + errhp (IN) - OCI Error Handle + column_value_type (IN) - ROW LCR column value type: + - OCI_LCR_ROW_COLVAL_OLD + - OCI_LCR_ROW_COLVAL_NEW + (See NOTES for special mode supported by this + function.) + num_columns (OUT) - Number of columns in requested column list + column_names (IN/OUT)- Pointer to an array of column names. + Optional. If specified then column_namesl must + be specified as well, and both arrays must be the + size specified by array_size parameter. + column_name_lens (IN/OUT)- Pointer to an array of column name lengths + in bytes, excluding the NULL terminator. + Optional. If specified then column_names must + be specified as well, and both arrays must be the + size specified by array_size parameter. + column_dtyp (IN/OUT)- Pointer to an array of column datatypes. + Optional. If specified then this array must be + the size specified by array_size parameter. + column_valuesp (IN/OUT)- Pointer to an array of column data values. + Optional. If specified then this array must be + the size specified by array_size parameter. + column_indp (IN/OUT)- Pointer to an indicator array. For all datatypes, + this is a pointer to an array of OCIInd values + (OCI_IND_NULL/OCI_IND_NOTNULL). + Optional. If specified then this array must be + the size specified by array_size parameter. + column_alensp (IN/OUT)- Pointer to an array of actual column lengths in + bytes. + Optional. If specified then this array must be + the size specified by array_size parameter. + column_csetfp (IN/OUT)- Pointer to an array of character set forms for + the columns. + Optional. If specified then this array must be + the size specified by array_size parameter. + column_flags (IN/OUT)- Pointer to an array of column flags for + the columns. + Optional. If specified then this array must be + the size specified by array_size parameter. + Possible bit values are OCI_LCR_COLUMN_* flags + listed above. + column_csid (IN/OUT)- Pointer to an array of column character set id for + the columns. + Optional. If specified then this array must be + the size specified by array_size parameter. + The column csid is returned only for XMLType + column. + row_lcrp (IN) - Streams Row LCR pointer + array_size (IN) - Size of each of above arrays + mode (IN) - mode (see NOTES) +NOTES + - For now, specify OCI_DEFAULT for mode + - If array_size is not large enough to accommodate the number of columns + in the requested column list then OCI_ERROR is returned. Parameter + num_columns will have the number of columns in the requested column list. + - The return values for column_names and column_valuesp will be shallow + copied (i.e., they reference directly into the LCR structure). + Client should not modify those pointers directly. + - Valid mode flags: + - OCILCR_NEW_ONLY_MODE: this mode is valid only for OCI_LCR_ROW_COLVAL_NEW + column_value_type; otherwise, an error is raised. + If this mode is specified then the columns returned include only the + columns in the NEW column list. + If this mode is not specified then the columns returned is the union + of the NEW columns plus the OLD columns that are not present in the + NEW column list. +------------------------------------------------------------------------------= +*/ +sword OCILCRRowColumnInfoGet(OCISvcCtx *svchp, + OCIError *errhp, + ub2 column_value_type, + ub2 *num_columns, + oratext **column_names, + ub2 *column_name_lens, + ub2 *column_dtyp, + void **column_valuesp, + OCIInd *column_indp, + ub2 *column_alensp, + ub1 *column_csetfp, + oraub8 *column_flags, + ub2 *column_csid, + void *row_lcrp, + ub2 array_size, + ub4 mode); + + +/* +------------------------------------------------------------------------------= +NAME + OCILCRDDLInfoSet - OCI LCR SET DDL INFO +DESCRIPTION + populates DDL information as sepcified by the user. +PARAMETERS + svchp (IN) - OCI service context + errhp (IN) - OCI Error Handle + object_type (IN) - The type of object on which the DDL statement was + executed. The following are valid object types: + CLUSTER, FUNCTION, INDEX, LINK, OUTLINE, + PACKAGE, PACKAGE BODY, PROCEDURE, SEQUENCE, + SYNONYM, TABLE, TRIGGER, TYPE, USER, VIEW + LINK represents a database link. + NULL is also a valid object type. Specify NULL + for all object types not listed. + object_type_len (IN) - Length of object_type without the NULL terminator. + ddl_text (IN) - The text of the DDL statement. This parameter + should be set to a non-NULL value. + DDL text must be in Oracle DDL format. + ddl_text_len (IN) - DDL text length in bytes without NULL terminator. + logon_user (IN) - Canonicalized name of the user whose session + executed the DDL statement. Should follow Oracle + naming conventions and size limitations. + logon_user_len (IN) - logon user name length in bytes without NULL + terminator. + current_schema (IN) - The canonicalized schema name that is used if no + schema is specified explicitly for the modified + database objects in ddl_text. If a schema is + specified in ddl_text that differs from the one + specified for current_schema, then the schema + specified in ddl_text will be used. + This parameter should be set to a non-NULL value. + Should follow Oracle naming conventions and size + limitations. + current_schema_len (IN) - schema name length in bytes without NULL terminator + base_table_owner (IN) - If the DDL statement is a table related DDL + (such as CREATE TABLE and ALTER TABLE), or if the + DDL statement involves a table (such as creating + a trigger on a table), then base_table_owner + specifies the canonicalized owner of the table + involved. Otherwise, base_table_owner is NULL. + Should follow Oracle naming conventions and size + limitations. + base_table_owner_len (IN)- base table owner name length in bytes without NULL + terminator. + base_table_name (IN) - If the DDL statement is a table related DDL (such + as CREATE TABLE and ALTER TABLE), or if the DDL + statement involves a table (such as creating a + trigger on a table), then base_table_name + specifies the canonicalized name of the table + involved. Otherwise, base_table_name is NULL. + Length of the above string without the NULL + terminator. Should follow Oracle naming + conventions and size limitations. + Should follow Oracle naming conventions and size + limitations. + base_table_name_len (IN)- base table name length in bytes without NULL + terminator. + flag (IN) - DDL LCR flag. + ddl_lcrp (IN/OUT) - Streams Ddl LCR pointer + mode (IN) - mode +NOTES + - For now, specify OCI_DEFAULT for mode +------------------------------------------------------------------------------= +*/ +sword OCILCRDDLInfoSet(OCISvcCtx *svchp, + OCIError *errhp, + oratext *object_type, + ub2 object_type_len, + oratext *ddl_text, + ub4 ddl_text_len, + oratext *logon_user, + ub2 logon_user_len, + oratext *current_schema, + ub2 current_schema_len, + oratext *base_table_owner, + ub2 base_table_owner_len, + oratext *base_table_name, + ub2 base_table_name_len, + oraub8 flag, + void *ddl_lcrp, + ub4 mode); + +/* +------------------------------------------------------------------------------= +NAME + OCILCRDDLInfoGet - OCI LCR GET DDL INFO +DESCRIPTION + Returns DDL information from specified lcr. +PARAMETERS + svchp (IN) - OCI service context + errhp (IN) - OCI Error Handle + object_type (OUT) - The type of object on which the DDL statement + was executed. + Optional, if object_type is specified then + must specify object_type_len as well. + object_type_len (OUT) - Length of object_type without the NULL + terminator. + ddl_text (OUT) - The text of the DDL statement. + Optional, if ddl_text is specified then + must specify ddl_text_len as well. + ddl_text_len (OUT) - DDL text length in bytes without NULL + terminator. + logon_user (OUT) - Canonicalized name of the user whose session + executed the DDL statement. + Optional, if logon_user is specified then + must specify logon_user_len as well. + logon_user_len (OUT) - logon user name length in bytes without NULL + terminator. + current_schema (OUT) - The canonicalized schema name that is used if + no schema is specified explicitly for the + modified database objects in ddl_text. + Optional, if current_schema is specified then + must specify current_schema_len as well. + current_schema_len (OUT)- schema name length in bytes without NULL + terminator + base_table_owner (OUT) - If the DDL statement is a table related DDL + (such as CREATE TABLE and ALTER TABLE), or if + the DDL statement involves a table (such as + creating a trigger on a table), then + base_table_owner specifies the canonicalized + owner of the table involved. Otherwise, + base_table_owner is NULL. Optional, if + base_table_owner is specified then must specify + base_table_owner_len as well. + base_table_owner_len (OUT) - base table owner name length in bytes without + NULL terminator. + base_table_name (OUT) - If the DDL statement is a table related DDL + (such as CREATE TABLE and ALTER TABLE), or if + the DDL statement involves a table (such as + creating a trigger on a table), then + base_table_name specifies the canonicalized name + of the table involved. Otherwise, + base_table_name is NULL. Optional, if + base_table_name is specified then must specify + base_table_name_len as well. + base_table_name_len (OUT) - base table name length in bytes without NULL + terminator. + flag (OUT) - DDL LCR flag. Optional, data not returned if + NULL. + ddl_lcrp (IN) - Streams DDL LCR pointer + mode (IN) - mode (for future extention - not used currently) +RETURNS + OCI_SUCCESS or OCI_ERROR. +NOTES + - For now, specify OCI_DEFAULT for mode +------------------------------------------------------------------------------= +*/ +sword OCILCRDDLInfoGet(OCISvcCtx *svchp, + OCIError *errhp, + oratext **object_type, + ub2 *object_type_len, + oratext **ddl_text, + ub4 *ddl_text_len, + oratext **logon_user, + ub2 *logon_user_len, + oratext **current_schema, + ub2 *current_schema_len, + oratext **base_table_owner, + ub2 *base_table_owner_len, + oratext **base_table_name, + ub2 *base_table_name_len, + oraub8 *flag, + void *ddl_lcrp, + ub4 mode); + +/* +------------------------------------------------------------------------------= +NAME + OCILCRAttributesSet - OCI LCR SET ATTRIBUTES +DESCRIPTION + populates extra attribute information in ROW/DDL LCR, as well as any + non first class attributes that can not be set through + OCILCRHeaderSet, OCILCRDDLInfoSet, or OCILCRRowColumnInfoSet. + e.g. edition name +PARAMETERS + svchp (IN) - OCI service context + errhp (IN) - OCI Error Handle + num_attrs (IN) - Number of extra attributes to be populated + attr_names (IN) - Pointer to an array of attribute names. Attribute + names must be canonicalized and should follow + Oracle naming conventions + attr_names_lens (IN) - Pointer to an array of attribute name lengths + in bytes, excluding the NULL terminator. + attr_dtyp (IN) - Pointer to an array of attribute datatypes. + attr_valuesp (IN) - Pointer to an array of attribute data values. + attr_indp (IN) - Pointer to an indicator array. For all datatypes, + this is a pointer to an array of OCIInd values + (OCI_IND_NULL/OCI_IND_NOTNULL). + attr_alensp (IN) - Pointer to an array of actual attribute lengths in + bytes. + lcrp (IN/OUT)- Streams (Row/DDL) LCR pointer + mode (IN) - mode +NOTES + - For now, specify OCI_DEFAULT for mode +------------------------------------------------------------------------------= +*/ +sword OCILCRAttributesSet(OCISvcCtx *svchp, + OCIError *errhp, + ub2 num_attrs, + oratext **attr_names, + ub2 *attr_name_lens, + ub2 *attr_dtyp, + void **attr_valuesp, + OCIInd *attr_indp, + ub2 *attr_alensp, + void *lcrp, + ub4 mode); + +/* +------------------------------------------------------------------------------= +NAME + OCILCRAttributesGet - OCI LCR GET EXTRA ATTRIBUTES +DESCRIPTION + Gets extra attribute information in (ROW/DDL) LCR, as well as any + non first class attributes that are not populated through + OCILCRHeaderGet, OCILCRDDLInfoGet, or OCILCRRowColumnInfoGet + e.g. edition name +PARAMETERS + svchp (IN) - OCI service context + errhp (IN) - OCI Error Handle + num_attrs (OUT) - Number of extra attributes to be populated + attr_names (IN/OUT)- Pointer to an array of attribute names. Attribute + names must be canonicalized and should follow + Oracle naming conventions + attr_namesl (IN/OUT)- Pointer to an array of attribute name lengths + in bytes, excluding the NULL terminator. + attr_dtyp (IN/OUT)- Pointer to an array of attribute datatypes. + attr_valuesp (IN/OUT)- Pointer to an array of attribute data values. + attr_indp (IN/OUT)- Pointer to an indicator array. For all datatypes, + this is a pointer to an array of OCIInd values + (OCI_IND_NULL/OCI_IND_NOTNULL). + attr_alensp (IN/OUT)- Pointer to an array of actual attribute lengths in + bytes. + lcrp (IN) - Streams (Row/DDL) LCR pointer + array_size (IN) - Size of each of above arrays, use at least the size + defined by OCI_LCR_MAX_ATTRIBUTES + mode (IN) - mode +NOTES + - For now, specify OCI_DEFAULT for mode + - If array_size is not large enough to accommodate the number of attributes + in the requested attribute list then OCI_ERROR is returned. Parameter + num_attrs will return the suggested size. +------------------------------------------------------------------------------= +*/ +sword OCILCRAttributesGet(OCISvcCtx *svchp, + OCIError *errhp, + ub2 *num_attrs, + oratext **attr_names, + ub2 *attr_namesl, + ub2 *attr_dtyp, + void **attr_valuesp, + OCIInd *attr_indp, + ub2 *attr_alensp, + void *lcrp, + ub2 array_size, + ub4 mode); + +/*--------------------- OCILCRWhereClauseGet ----------------------------*/ +/* + NAME + OCILCRWhereClauseGet - OCI Get Where Clause + DESCRIPTION + Gets the Where clause statement for the given ROW LCR. + PARAMETERS + svchp (IN/OUT) - OCI service handle + errhp (IN/OUT) - Error Handle to which errors + should be reported + wc_stmt (OUT) - Sql Statement equivalent to the + LCR has applied + wc_stmt_len (IN/OUT) - length of wc_stmt buffer + row_lcrp (IN) - row LCR to be converted to SQL + mode (IN) - Mode flags (For future extension. + Not used currently) + RETURNS + OCI_SUCCESS or OCI_ERROR. + NOTES + - For now, specify OCI_DEFAULT for mode + - WHERE clause generated for INSERT lcr will have all the columns that + are being inserted. This WHERE clause could be used to identify the + inserted row after inserting. (like "returning ROWID"). + INSERT INTO TAB(COL1) VALUES (10) -> WHERE COL1=10 + - WHERE clause generated for UPDATE will have all the columns in the + old column list. However the values of the columns will be that of + new value if it exist in the new column list + of the UPDATE. If the column doesnt have new value then the old column + value will be used. + UPDATE TAB SET COL1 = 10 WHERE COL1 = 20 -> WHERE COL1 = 10 + UPDATE TAB SET COL2 = 20 WHERE COL1 = 20 -> WHERE COL1 = 20 + - WHERE clause for DELETE will use the columns and values from + old column lst + - LOB piecewise operations would use the new columns and values for + generating the WHERE clause. +*/ + +sword OCILCRWhereClauseGet( + OCISvcCtx *svchp, + OCIError *errhp, + oratext *wc_stmt, + ub4 *wc_stmt_len, + void *row_lcrp, + ub4 mode); + +/*--------------------- OCILCRRowStmtGet ----------------------------*/ +/* + NAME + OCILCRRowStmtGet - OCI Get Row Statement + DESCRIPTION + Gets the SQL statement for the given ROW LCR. + PARAMETERS + svchp (IN/OUT) - OCI service handle + errhp (IN/OUT) - Error Handle to which errors + should be reported + row_stmt (OUT) - Sql Statement equivalent to the + LCR has applied + row_stmt_len (IN/OUT) - length of row_stmt buffer + row_lcrp (IN) - row LCR to be converted to SQL + mode (IN) - Mode flags (For future extension. + Not used currently) + RETURNS + OCI_SUCCESS or OCI_ERROR. + NOTES + None +*/ +sword OCILCRRowStmtGet( + OCISvcCtx *svchp, + OCIError *errhp, + oratext *row_stmt, + ub4 *row_stmt_len, + void *row_lcrp, + ub4 mode); + +/*--------------------- OCILCRWhereClauseWithBindVarGet ----------------------*/ +/* + NAME + OCILCRWhereClauseWithBindVarGet - OCI Get Where clause with binds + DESCRIPTION + Gets the where clause statement with bind variables for the given ROW LCR. + PARAMETERS + svchp (IN/OUT) - OCI service handle + errhp (IN/OUT) - Error Handle to which errors + should be reported + wc_stmt (OUT) - Sql Stmt equivalent to the LCR + wc_stmt_len (IN/OUT) - length of wc_stmt buffer + num_bind_var (OUT) - Number of bind variables + bind_var_dtyp (OUT) - Array of Data types of bind + variables + bind_var_valuesp (OUT) - Array of Values of bind variables + bind_var_indp (OUT) - Array of null indicators of + bind variables + bind_var_alensp (OUT) - Array of lengths of bind values + bind_var_csetidp (OUT) - Array of char set id of binds + bind_var_csetfp (OUT) - Array of char set form of binds + row_lcrp (IN) - row LCR to be converted to SQL + array_size (IN) - Size of the array of bind values + bind_var_syntax (IN) - Native syntax to be used for binds + mode (IN) - Mode flags (For future extension. + Not used currently) + RETURNS + OCI_SUCCESS or OCI_ERROR. + NOTES + - For now, specify OCI_DEFAULT for mode + - If array_size is not large enough to accommodate the number of columns + in the requested column list then OCI_ERROR is returned. Expected + array_size is returned through num_bind_var parameter. + - bind_var_syntax for oracle should contain ":". This will generate + positional binds such as :1, :2, :3 etc. For other non-oracle databases + they can give the string that needs to be used for binds. + - WHERE clause generated for INSERT lcr will have all the columns that + are being inserted. This WHERE clause could be used to identify the + inserted row after inserting. (like "returning ROWID"). + INSERT INTO TAB(COL1) VALUES (10) -> WHERE COL1=10 + - WHERE clause generated for UPDATE will have all the columns in the + old column list. However the values of the columns will be that of + new column value of the column if it exist in the new values + of the UPDATE. If the column appears only in the old column then + old column value will be used. + UPDATE TAB SET COL1 = 10 WHERE COL1 = 20 -> WHERE COL1 = 10 + UPDATE TAB SET COL2 = 20 WHERE COL1 = 20 -> WHERE COL1 = 20 + - WHERE clause for DELETE will use the columns and values from + old column lst + - LOB piecewise operations would use the new columns and values for + generating the WHERE clause. +*/ +sword OCILCRWhereClauseWithBindVarGet( + OCISvcCtx *svchp, + OCIError *errhp, + oratext *wc_stmt, + ub4 *wc_stmt_len, + ub2 *num_bind_var, + ub2 *bind_var_dtyp, + void **bind_var_valuesp, + OCIInd *bind_var_indp, + ub2 *bind_var_alensp, + ub2 *bind_var_csetidp, + ub1 *bind_var_csetfp, + void *row_lcrp, + ub2 array_size, + oratext *bind_var_syntax, + ub4 mode); + +/*--------------------- OCILCRRowStmtWithBindVarGet ----------------------*/ +/* + NAME + OCILCRRowStmtWithBindVarGet - OCI Get Row Statement + DESCRIPTION + Gets the SQL statement with bind variables for the given ROW LCR. + PARAMETERS + svchp (IN/OUT) - OCI service handle + errhp (IN/OUT) - Error Handle to which errors + should be reported + row_stmt (OUT) - Sql Stmt equivalent to the LCR + row_stmt_len (IN/OUT) - length of row_stmt buffer + num_bind_var (OUT) - Number of bind variables + bind_var_dtyp (OUT) - Array of Data types of bind + variables + bind_var_valuesp (OUT) - Array of Values of bind variables + bind_var_indp (OUT) - Array of null indicators of + bind variables + bind_var_alensp (OUT) - Array of lengths od bind values + bind_var_csetidp (OUT) - Array of char set id of binds + bind_var_csetfp (OUT) - Array of char set form of binds + row_lcrp (IN) - row LCR to be converted to SQL + chunk_column_names (OUT) - Array of chunked column names in + lcr + chunk_column_namesl (OUT) - Length of chunk_column_names + chunk_column_flags (OUT) - flags of chunked columns in lcr + Possible bit values are + OCI_LCR_COLUMN_* flags listed + above. + array_size (IN) - Size of the array of bind values + bind_var_syntax (IN) - Native syntax to be used for binds + mode (IN) - Mode flags (For future extension. + Not used currently) + RETURNS + OCI_SUCCESS or OCI_ERROR. + NOTES + - For now, specify OCI_DEFAULT for mode + - If array_size is not large enough to accommodate the number of columns + in the requested column list then OCI_ERROR is returned. Expected + array_size is returned through num_bind_var parameter. + - bind_var_syntax for oracle should contain ":". This will generate + positional binds such as :1, :2, :3 etc. For other non-oracle databases + they can give the string that needs to be used for binds. +*/ +sword OCILCRRowStmtWithBindVarGet( + OCISvcCtx *svchp, + OCIError *errhp, + oratext *row_stmt, + ub4 *row_stmt_len, + ub2 *num_bind_var, + ub2 *bind_var_dtyp, + void **bind_var_valuesp, + OCIInd *bind_var_indp, + ub2 *bind_var_alensp, + ub2 *bind_var_csetidp, + ub1 *bind_var_csetfp, + void *row_lcrp, + oratext **chunk_column_names, + ub2 *chunk_column_namesl, + oraub8 *chunk_column_flags, + ub2 array_size, + oratext *bind_var_syntax, + ub4 mode); + +/* +------------------------------------------------------------------------------- + NAME + OCILCRSCNsFromPosition - Get SCNs From Position + + DESCRIPTION + Returns the SCN and commit SCN from the given position. + PARAMETERS + svchp (IN) - OCI service context + errhp (IN) - OCI Error Handle + position (IN) - LCR position + position_len (IN) - length of position + scn (OUT) - the SCN stored in position + commit_scn (OUT) - the commit SCN stored in position + mode (IN) - Mode flags (For future extension. Not used + currently) + RETURN + OCI_SUCCESS if the conversion succeeds, OCI_ERROR otherwise. + NOTE + The user must allocate memory for the return numbers. + The input position must conform to the format generated by an XStream + server. +------------------------------------------------------------------------------- +*/ +sword OCILCRSCNsFromPosition(OCISvcCtx *svchp, + OCIError *errhp, + ub1 *position, + ub2 position_len, + OCINumber *scn, + OCINumber *commit_scn, + ub4 mode); + +/* +------------------------------------------------------------------------------- + NAME + OCILCRSCNToPosition - Converts SCN To Position + + DESCRIPTION + Converts an SCN to a position. The generated position can be passed as the + last_position to OCIXStreamOutAttach function to filter the LCRs + with commit SCN less than the given SCN and the LCR's SCN less than the + given SCN. This means the first LCR sent by the Outbound server is either + - a commit LCR at the given SCN, or + - the first LCR of the subsequent transaction with commit SCN greater + than or equal to the given SCN. + PARAMETERS + svchp (IN) - OCI service context + errhp (IN) - OCI Error Handle + position (OUT) - Result position. Must pre-allocate + OCI_LCR_MAX_POSITION_LEN bytes. + position_len (OUT) - Length of position + scn (IN) - The SCN to be stored in position + mode (IN) - Mode flags (for future extension) + RETURN + OCI_SUCCESS if the conversion succeeds, OCI_ERROR otherwise. +------------------------------------------------------------------------------- +*/ +sword OCILCRSCNToPosition(OCISvcCtx *svchp, + OCIError *errhp, + ub1 *position, + ub2 *position_len, + OCINumber *scn, + ub4 mode); + +/* +------------------------------------------------------------------------------= +NAME + OCILCRLobInfoGet - OCI LCR GET LOB INFO +DESCRIPTION + Returns the LOB information for a given piece-wise LOB LCR. +PARAMETERS + svchp (IN) - OCI service context + errhp (IN) - OCI Error Handle + column_name (OUT) - Pointer to the LOB column name. + Optional. If specified then column_name_len must + be specified as well. + column_name_len(OUT) - Length of LOB column name without the NULL + terminator. + column_dty (OUT) - LOB column dty - either SQLT_CHR (for CLOB) or + SQLT_BIN (for BLOB). + column_flag (OUT) - LOB column flag. + Possible bit values are OCI_LCR_COLUMN_* flags + listed above. + offset (OUT) - LOB operation offset in code points. Returned only + for LOB_TRIM and LOB_WRITE operations; otherwise, + a zero is returned. + This is the same as the 'soffset' parameter for + OCILobErase or the 'offset' parameter in + OCILobWrite functions. + size (OUT) - LOB operation size in code points. Returned only + for LOB_TRIM and LOB_ERASE operations; otherwise, + a zero is returned. + This is the same as the 'new_length' parameter in + OCILobTrim or the 'amtp' parameter in OCILobErase + functions. + row_lcrp (IN) - Streams Row LCR pointer + mode (IN) - mode +NOTES + - For now, specify OCI_DEFAULT for mode +------------------------------------------------------------------------------= +*/ +sword OCILCRLobInfoGet(OCISvcCtx *svchp, + OCIError *errhp, + oratext **column_name, + ub2 *column_name_len, + ub2 *column_dty, + oraub8 *column_flag, + ub4 *offset, + ub4 *size, + void *row_lcrp, + ub4 mode); + +/* +------------------------------------------------------------------------------= +NAME + OCILCRLobInfoSet - OCI LCR SET LOB INFO +DESCRIPTION + Sets the LOB information for a given piece-wise LOB LCR. +PARAMETERS + svchp (IN) - OCI service context + errhp (IN) - OCI Error Handle + column_name (IN) - Pointer to the LOB column name. + column_name_len(IN) - Length of LOB column name without the NULL + terminator. + column_dty (IN) - LOB column dty - either SQLT_CHR (for CLOB) or + SQLT_BIN (for BLOB). + column_flag (IN) - LOB column flag. + Possible bit values are OCI_LCR_COLUMN_* flags + listed above. + offset (IN) - LOB operation offset in code points. Returned only + for LOB_TRIM and LOB_WRITE operations; otherwise, + a zero is returned. + This is the same as the 'soffset' parameter for + OCILobErase or the 'offset' parameter in + OCILobWrite functions. + size (IN) - LOB operation size in code points. Returned only + for LOB_TRIM and LOB_ERASE operations; otherwise, + a zero is returned. + This is the same as the 'new_length' parameter in + OCILobTrim or the 'amtp' parameter in OCILobErase + functions. + row_lcrp (IN/OUT)- Streams Row LCR pointer + mode (IN) - mode +NOTES + - For now, specify OCI_DEFAULT for mode +------------------------------------------------------------------------------= +*/ +sword OCILCRLobInfoSet(OCISvcCtx *svchp, + OCIError *errhp, + oratext *column_name, + ub2 column_name_len, + ub2 column_dty, + oraub8 column_flag, + ub4 offset, + ub4 size, + void *row_lcrp, + ub4 mode); + +/*--------------------------------------------------------------------------- + STREAMS XSTREAM OUT FUNCTIONS + ---------------------------------------------------------------------------*/ + +/*------------------------- OCIXStreamOutAttach -----------------------------*/ +/* + NAME + OCIXStreamOutAttach - OCI Attach to XStreams Out + DESCRIPTION + Given the name of the server process, attach to the outbound server. + PARAMETERS + svchp (IN/OUT) - OCI service handle + errhp (IN/OUT) - Error Handle for error reporting + server_name (IN) - Server name. + server_name_len (IN) - Length of server name. + last_position (IN) - last rcv position. (Optional) + last_position_len (IN) - Length of last_position. + mode (IN) - Mode flags (future extension. + Not used currently) + RETURNS + OCI_SUCCESS or OCI_ERROR. + NOTES + Specify OCI_DEFAULT for the mode parameter. + + The name of the outbound server must be provided because multiple + outbound servers can be configured in one Oracle instance. This call + returns OCI_ERROR if it encounters any error while attaching to the + outbound server. + + The last_position parameter is used to establish the starting point + of the stream. This call returns OCI_ERROR if the specified position + is non-null and less than the server's processed low-watermark; + otherwise, LCRs with position greater than last_position will be + sent to the user. + + If last_position is null then the stream will start from the processed + low-watermark maintained in the server. +*/ + +sword OCIXStreamOutAttach (OCISvcCtx *svchp, OCIError *errhp, + oratext *server_name, ub2 server_name_len, + ub1 *last_position, + ub2 last_position_len, + ub4 mode); + +#define OCIXSTREAM_OUT_ATTACH_RESERVED_1 (0x00000001) + +/*---------------------- OCIXStreamOutProcessedLWMSet ----------------------*/ +/* + NAME + OCIXStreamOutProcessedLWMSet - Set Processed Low-Watermark + DESCRIPTION + Sets the processed low-watermark maintained at the client. + PARAMETERS + svchp (IN/OUT) - OCI service handle + errhp (IN/OUT) - Error Handle for error reporting + processed_low_position (IN) - processed low position. + processed_low_position_len (IN) - processed low position length. + mode (IN) - mode for future extension. (Not used + currently). + RETURNS + OCI_SUCCESS or OCI_ERROR. + + NOTES + The processed low-watermark denotes all LCRs at or below this position + have been processed. After successfully attaching to an XStream + outbound server, a local copy of the processed low-watermark is + maintained at the client. Periodically, this watermark is sent to the + server so that archived logs containing already processed transactions + can be purged. + + The following API is used to update the local copy of the processed + low-watermark. It can be called anytime between OCIXStreamOutAttach + and OCIXStreamOutDetach calls. Clients, using the callback mechanism + to stream LCRs from the server, can invoke this API while + in the callback functions. +*/ + +sword OCIXStreamOutProcessedLWMSet (OCISvcCtx *svchp, OCIError *errhp, + ub1 *processed_low_position, + ub2 processed_low_position_len, + ub4 mode); + + +/*-------------------- OCICallbackXStreamOutLCRProcess ----------------------*/ +/* + NAME + OCICallbackXStreamOutLCRProcess - Callback to process each LCR received + DESCRIPTION + This callback is invoked during OCIXStreamOutLCRCallbackReceive + to process each LCR received from the outbound server. + PARAMETERS + usrctxp (IN/OUT) - Ptr to the user context. + lcrp (IN) - Pointer to the LCR just received. + lcrtyp (IN) - LCR type (OCI_LCR_XROW / OCI_LCR_XDDL) + flag (IN) - If OCI_XSTREAM_MORE_ROW_DATA is set, + this means the current LCR has more + chunk data. + RETURNS + This callback function must return OCI_CONTINUE to continue processing + OCIXStreamOutLCRCallbackReceive call. Any return code other than + OCI_CONTINUE signals that the client wants to terminate + OCIXStreamOutLCRCallbackReceive immediately. +*/ +typedef sb4 (*OCICallbackXStreamOutLCRProcess) (void *usrctxp, void *lcrp, + ub1 lcrtyp, oraub8 flag); + + +/*-------------------- OCICallbackXStreamOutChunkProcess --------------------*/ +/* + NAME + OCICallbackXStreamOutChunkProcess - Callback to process each chunk + DESCRIPTION + This callback is invoked during OCIXStreamOutLCRCallbackReceive + to process each chunk in an LCR. + PARAMETERS + usrctxp (IN/OUT) - Ptr to the user context. + column_name (IN) - Column name for the current chunk. + column_name_len (IN) - Length of column name. + column_dty (IN) - Chunk data type (SQLT_CHR or SQLT_BIN). + column_flag (IN) - LCR column flags. Possible bit values are + OCI_LCR_COLUMN_* flags listed above. + column_csid (IN) - Column character set id. Relevant only if + the column is an XMLType column (i.e., + column_flag has OCI_LCR_COLUMN_XML_DATA bit set). + chunk_bytes (IN) - Chunk data length in bytes. + chunk_data (IN) - Chunk data buffer. + flag (IN) - If OCI_XSTREAM_MORE_ROW_DATA is set, this means + the current LCR has more chunks. + RETURNS + This callback function must return OCI_CONTINUE to continue processing + OCIXStreamOutLCRCallbackReceive call. Any return code other than + OCI_CONTINUE signals that the client wants to terminate + OCIXStreamOutLCRCallbackReceive immediately. +*/ +typedef sb4 (*OCICallbackXStreamOutChunkProcess) + (void *usrctxp, oratext *column_name, ub2 column_name_len, + ub2 column_dty, oraub8 column_flag, ub2 column_csid, + ub4 chunk_bytes, ub1 *chunk_data, oraub8 flag); + +/*-------------------- OCIXStreamOutLCRCallbackReceive ----------------------*/ +/* + NAME + OCIXStreamOutLCRCallbackReceive - OCI Receive LCR stream using Callbacks + DESCRIPTION + This API is used to get the LCR stream from the outbound server using + callbacks to gain better performance. The user must supply a callback + function to be invoked for each LCR received. If some row changes + in the stream may contain LOB/LONG/XMLType columns then the data for + those columns are returned to the user in chunks. To receive those row + changes, the user must provide a second callback to be invoked to + process each chunk data. + + If there is an LCR available in the stream, the processlcr_cb function + is invoked immediately. After the processlcr_cb function exits, if the + current LCR contains additional chunks then the processchunk_cb function + is invoked for each chunk belonging to that LCR. + + If there is no LCR in the stream when the idle timeout expires (see + OCI_ATTR_XSTREAM_IDLE_TIMEOUT), this call returns a null LCR with + OCI_SUCCESS code. + PARAMETERS + svchp (IN/OUT) - OCI service handle + errhp (IN/OUT) - Error Handle for error reporting + processlcr_cb (IN) - Client callback function for each LCR. + processchunk_cb (IN) - Client callback function for each + chunk. + usrctxp (IN) - Client context. (Optional) + fetch_low_position (OUT)- Fetch low watermark. (Optional) + fetch_low_position_len (OUT)- Fetch low watermark length. + mode (IN) - mode for future extension. (Not used + currently). + RETURNS + OCI_SUCCESS or OCI_ERROR. + NOTES + - The fetch low watermark is used to indicate all transactions + with commit position below this have been received by the XStream + outbound server. + + - If the LCR contains non-chunked column(s), the duration of that LCR is + limited to the processlcr_cb function. If the LCR contains some + chunk data then the duration of the LCR is extended until all the + chunks have been processed (that is, when the flag passing to + processchunk_cb function does not have OCI_XSTREAM_MORE_ROW_DATA flag + set). If the user wants to access the LCR data at a later time, a + copy of the LCR must be made. The client callback should not modify + or free the LCR passing to the callback. + + - The given usrctxp is passed to both callbacks. + + - An ACK interval is the interval in seconds which the outbound + server receives the processed LWM or the inbound server sends + the processed LWM. The default ACK interval is 30 seconds. This + value can be changed by setting the OCI_ATTR_XSTREAM_ACK_INTERVAL + attribute using OCIAttrSet API. This attribute is checked only + during the Attach call; thus, it must be set before invoking this API. + + - The idle timeout is the interval in seconds after which the current + call will terminate if there is no LCR in the stream. The default + idle timeout is one second. This value can be changed by setting the + OCI_ATTR_XSTREAM_IDLE_TIMEOUT attribute using OCIAttrSet API. This + attribute is checked only during the Attach call; thus, it must be + set before invoking this API. + + - The outbound server ends each call at the transaction boundary + after an ACK interval has elapsed from the start of the call + or when the idle timeout expires. This API returns the fetch + low watermark at the end of each call. +*/ +sword OCIXStreamOutLCRCallbackReceive( + OCISvcCtx *svchp, OCIError *errhp, + OCICallbackXStreamOutLCRProcess processlcr_cb, + OCICallbackXStreamOutChunkProcess processchunk_cb, void *usrctxp, + ub1 *fetch_low_position, ub2 *fetch_low_position_len, ub4 mode); + +/*---------------------- OCIXStreamOutLCRReceive -------------------------*/ +/* + NAME + OCIXStreamOutLCRReceive - Receive LCR without using callback + DESCRIPTION + This API is used to receive an LCR from an outbound stream. If there + is an LCR available, this API immediately returns that LCR. The + duration of each LCR is limited to the processlcr_cb function. + When there is no LCR available in the stream, this call returns a + null LCR after the idle timeout (see OCI_ATTR_XSTREAM_IDLE_TIMEOUT) + has expired. + + To avoid network round trip for every OCIXStreamOutLCRReceive call, + the connection is tied to this call to let the server fill up + the network buffer with LCRs so subsequent calls can quickly receive + the LCRs from the network. The server ends each call at the + transaction boundary after an ACK interval has elapsed since the start + of the call or when the idle timeout expires. See + OCI_ATTR_XSTREAM_ACK_INTERVAL & OCI_ATTR_XSTREAM_IDLE_TIMEOUT + attributes. + PARAMETERS + svchp (IN/OUT) - OCI service handle + errhp (IN/OUT) - Error Handle for error reporting + lcrp (OUT) - Pointer to the LCR received from the + stream. + lcrtype (OUT) - LCR type (OCI_LCR_XROW / OCI_LCR_XDDL) + flag (OUT) - If OCI_XSTREAM_MORE_ROW_DATA is set, + it means the current LCR has more + chunk data. + fetch_low_position (OUT)- Fetch low watermark. (Optional) + fetch_low_position_len (OUT)- Fetch low watermark length. + mode (IN) - mode for future extension. (Not used + currently). + RETURNS + - OCI_STILL_EXECUTING means the current call is still in progress. The + connection associated with the specified service context handle is + still tied to this call for streaming the LCRs from the server. An + error is returned if the user attempts to use the same connection to + execute any OCI calls that require database round trip, for example, + OCIStmtExecute, OCIStmtFetch, OCILobRead, etc. OCILcr* calls are + local calls; thus, they are valid while the stream is in progress. + - OCI_SUCCESS means the current call is completed. User is free to + execute OCIStmt*, OCILob*, etc. from the same service context. + - OCI_ERROR means the current call encounters some errors. Use + OCIErrorGet to obtain information about the error. + + NOTES + This call always returns a null LCR when the return code is OCI_SUCCESS. + In addition, it returns the fetch low position to denote the outbound + server has received all transactions with commit position lower than or + equal to this value. +*/ + +sword OCIXStreamOutLCRReceive( + OCISvcCtx *svchp, OCIError *errhp, + void **lcrp, + ub1 *lcrtype, + oraub8 *flag, + ub1 *fetch_low_position, + ub2 *fetch_low_position_len, + ub4 mode); + +/*-------------------------- OCIXStreamOutChunkReceive ---------------------*/ +/* + NAME + OCIXStreamOutChunkReceive - Receive Chunk data + DESCRIPTION + Receives next chunk of LCR data from XStream Outbound server. + This API can only be called while OCIXStreamOutLCRReceive call is + in progress. + PARAMETERS + svchp (IN/OUT) - OCI service handle + errhp (IN/OUT) - Error Handle to which errors should be reported + column_name (OUT) - Name of column for which data is retrieved. + column_name_len (OUT) - Length of column name. + column_dty (OUT) - LCR column data type. + column_flag (OUT) - LCR column flag. Possible bit values are + OCI_LCR_COLUMN_LOB_DATA + OCI_LCR_COLUMN_LONG_DATA + OCI_LCR_COLUMN_EMPTY_LOB + OCI_LCR_COLUMN_LAST_CHUNK + OCI_LCR_COLUMN_AL16UTF16 + OCI_LCR_COLUMN_ENCRYPTED + OCI_LCR_COLUMN_NCLOB + OCI_LCR_COLUMN_XML_DATA + OCI_LCR_COLUMN_XML_DIFF + column_csid (OUT) - Column character set id. This is returned only + if the column is an XMLType column (i.e., + column_flag has OCI_LCR_COLUMN_XML_DATA bit + set). + chunk_bytes (OUT) - Number of bytes in output buffer. + chunk_data (OUT) - Pointer to the chunk data in the LCR. + Client must not de-allocate this pointer. + flag (OUT) - If OCI_XSTREAM_MORE_ROW_DATA is set, it means + the current LCR has more data coming. + mode (IN) - mode for future extension. (Not used currently). + RETURNS + OCI_SUCCESS - Check colname_len and chunk_bytes to determine the + data just read. + OCI_ERROR - Error encountered. Execute OCIErrorGet to get information + about the error. + NOTES + - If the return code is OCI_SUCCESS, client should check chunk_bytes to + determine the # of bytes read and check column_name to determine + which LCR column the data associated with. + + - All the chunks from one LOB/LONG/XMLType column are returned entirely + before the chunk value for the next LOB/LONG/XMLType column is + returned. + + - The is no fixed ordering on how the LOB/LONG/XMLType columns is + returned. Users must check the column name to determine which column. + The column_flag will have OCI_LCR_COLUMN_LAST_CHUNK bit set when this + function returns the last chunk of each column. + + - This call returns a null column name and null chunk data if it's + invoked when the current LCR contains only non-chunked columns. + + - If OCIXStreamOutLCRReceive call returns OCI_XSTREAM_MORE_ROW_DATA flag + then the user must iteratively call OCIXStreamOutChunkReceive to + retrieve all the chunks belonging to the current row change before + calling the next OCIXStreamOutLCRReceive. + +*/ +sword OCIXStreamOutChunkReceive(OCISvcCtx *svchp, OCIError *errhp, + oratext **column_name, ub2 *column_name_len, + ub2 *column_dty, oraub8 *column_flag, + ub2 *column_csid, ub4 *chunk_bytes, + ub1 **chunk_data, oraub8 *flag, ub4 mode); + +/*------------------------- OCIXStreamOutDetach -----------------------------*/ +/* + NAME + OCIXStreamOutDetach - OCI Detach from XStream Out + DESCRIPTION + Detaches from the attached XStream outbound server. This call sends the + current local processed low-watermark to the server before detaching + from the outbound server. The outbound server automatically restarts + after this call. This API returns OCI_ERROR if it is invoked while a + ReceiveLCR call is in progress. + PARAMETERS + svchp (IN/OUT) - OCI service handle + errhp (IN/OUT) - Error Handle to which errors should be reported + mode (IN) - mode for future extension. (Not used currently). + RETURNS + OCI_SUCCESS or OCI_ERROR. + NOTES + - The processed_low_position is passed to the server so it can update its + copy. This value if provided must be greater than or equal to the + value maintained in the server; otherwise, an error is returned. +*/ +sword OCIXStreamOutDetach (OCISvcCtx *svchp, OCIError *errhp, ub4 mode); + + +/*--------------------------------------------------------------------------- + STREAMS XSTREAM IN FUNCTIONS + ---------------------------------------------------------------------------*/ + +/*------------------------ OCIXStreamInAttach -------------------------------*/ +/* + NAME + OCIXStreamInAttach - OCI XStream In Attach + DESCRIPTION + Attaches to the specified XStream inbound server. + PARAMETERS + svchp (IN/OUT) - OCI service handle + errhp (IN/OUT) - Error Handle to which errors + should be reported + server_name (IN) - XStream inbound server name. + server_name_len (IN) - Length of server name. + source_name (IN) - source name to identify the data src. + source_name_len (IN) - Length of source name. + last_position (OUT) - Last position received by inbound + server. Optional. If specified must + pre-allocate OCI_LCR_MAX_POSITION_LEN + bytes for return value. + last_position_len (OUT) - Length of last_position. Must be + non-NULL if last_position is non-NULL. + mode (IN) - Mode flags (For future extension. + (Not used currently) + RETURNS + OCI_SUCCESS or OCI_ERROR. + NOTES + The last_position parameter is returned to establish the starting point + to resume the inbound stream. The client should start sending LCRs with + positions greater than the last_position since the inbound server will + ignore all LCRs with positions less than or equal to this value. +*/ + +sword OCIXStreamInAttach( + OCISvcCtx *svchp, + OCIError *errhp, + oratext *server_name, + ub2 server_name_len, + oratext *source_name, + ub2 source_name_len, + ub1 *last_position, + ub2 *last_position_len, + ub4 mode); + +/*-------------------- OCICallbackXStreamInLCRCreate ------------------------*/ +/* + NAME + OCICallbackXStreamInLCRCreate - Callback to create an LCR + DESCRIPTION + This callback is invoked during OCIXStreamInLCRCallbackSend + to create each LCR to be sent to the inbound server. + PARAMETERS + usrctxp (IN/OUT) - Ptr to the user context + lcrp (OUT) - Pointer to the LCR to be sent + lcrtyp (OUT) - LCR type (OCI_LCR_XROW / OCI_LCR_XDDL) + flag (OUT) - If OCI_XSTREAM_MORE_ROW_DATA is set, + this means the current LCR has more + chunk data. + RETURNS + This callback function must return OCI_CONTINUE to continue processing + OCIXStreamInLCRCallbackSend call. Any return code other than + OCI_CONTINUE signals that the client wants to terminate + OCIXStreamInLCRCallbackSend immediately. +*/ +typedef sb4 (*OCICallbackXStreamInLCRCreate)( + void *usrctxp, + void **lcrp, + ub1 *lcrtyp, + oraub8 *flag); + +/*-------------------- OCICallbackXStreamInChunkCreate --------------------*/ +/* + NAME + OCICallbackXStreamInChunkCreate - Callback to create each chunk + DESCRIPTION + This callback is invoked during OCIXStreamInLCRCallbackSend + to create each chunk to be sent to the inbound server. + PARAMETERS + usrctxp (IN/OUT) - Ptr to the user context. + column_name (OUT) - Column name for the current chunk. + column_name_len (OUT) - Length of column name. + column_dty (OUT) - Chunk data type (SQLT_CHR or SQLT_BIN). + column_flag (OUT) - LCR column flags. Possible bit values are + OCI_LCR_COLUMN_* flags listed above. + column_csid (OUT) - Column character set id. Relevant only if + the column is an XMLType column (i.e., + column_flag has OCI_LCR_COLUMN_XML_DATA bit + set). + chunk_bytes (OUT) - Chunk data length in bytes. + chunk_data (OUT) - Chunk data buffer. + flag (OUT) - If OCI_XSTREAM_MORE_ROW_DATA is set, this means + the current LCR has more chunks. + RETURNS + This callback function must return OCI_CONTINUE to continue processing + OCIXStreamInLCRCallbackSend call. Any return code other than + OCI_CONTINUE signals that the client wants to terminate + OCIXStreamInLCRCallbackSend immediately. +*/ +typedef sb4 (*OCICallbackXStreamInChunkCreate)( + void *usrctxp, + oratext **column_name, + ub2 *column_name_len, + ub2 *column_dty, + oraub8 *column_flag, + ub2 *column_csid, + ub4 *chunk_bytes, + ub1 **chunk_data, + oraub8 *flag); + +/*--------------------- OCIXStreamInLCRCallbackSend ------------------------*/ +/* + NAME + OCIXStreamInLCRCallbackSend - OCI XStream In Send LCR to Inbound Server + DESCRIPTION + Sends LCR stream to XStream inbound server using callbacks. + The API invokes createlcr_cb function to obtain each LCR to send to the + server. If the return flag from the createlcr_cb function has + OCI_XSTREAM_MORE_ROW_DATA bit set, then it invokes createchunk_cb + procedure to obtain each chunk. It repeatedly calls createchunk_cb + function while the flag returned from this callback has + OCI_XSTREAM_MORE_ROW_DATA bit set. When this bit is not set, this API + cycles back to invoke createlcr_cb function to get the next LCR. + This cycle is repeated until the createlcr_cb function returns a null + LCR or when an ACK interval has elapsed since the start of the call. + See OCI_ATTR_XSTREAM_ACK_INTERVAL attribute. + PARAMETERS + svchp (IN/OUT) - OCI service handle + errhp (IN/OUT) - Error Handle to which errors + should be reported + createlcr_cb (IN) - Callback function to be invoked + to generate an LCR for streaming. + Cannot be null. + createchunk_cb (IN) - Callback function to be invoked to + create each chunk. Can be null if the + user does not need to send any LCR with + LOB/LONG/XMLType columns. OCI_ERROR + will be returned if this argument is + null and the user attempts to send an + LCR with additional chunk data. + usrctxp (IN) - Client context to pass to both + callback functions. + mode (IN) - Mode flags (For future extension. + Not used currently) + RETURNS + OCI_SUCCESS or OCI_ERROR. + NOTES + None +*/ + +sword OCIXStreamInLCRCallbackSend( + OCISvcCtx *svchp, + OCIError *errhp, + OCICallbackXStreamInLCRCreate createlcr_cb, + OCICallbackXStreamInChunkCreate createchunk_cb, + void *userctxp, + ub4 mode); + +/*---------------------------- OCIXStreamInLCRSend --------------------------*/ +/* + NAME + OCIXStreamInLCRSend - OCI XStream In Send LCR to Inbound Server + DESCRIPTION + Sends LCR stream to XStream inbound server without using callbacks. + To avoid a network round trip for every OCIXStreamInLCRSend call, + the connection is tied to this call for at least the duration + specified by the OCI_ATTR_XSTREAM_ACK_INTERVAL attribute. + PARAMETERS + svchp (IN/OUT) - OCI service handle + errhp (IN/OUT) - Error Handle to which errors + should be reported + lcrp (IN) - Pointer to the LCR to send. Cannot + be null. + lcrtype (IN) - LCR type (OCI_LCR_XROW / OCI_LCR_XDDL) + flag (IN) - If OCI_XSTREAM_MORE_ROW_DATA is set, + it means the current LCR has more + chunk data. + mode (IN) - Mode flags (For future extension. + Not used currently) + RETURNS + - OCI_STILL_EXECUTING means the current call is still in progress. The + connection associated with the specified service context handle is + still tied to this call for streaming the LCRs to the server. An error + is returned if the user attempts to use the same connection to + execute any OCI calls that require database round trip, for example, + OCIStmtExecute, OCIStmtFetch, OCILobRead, etc. OCILcr* calls are + local calls; thus, they are valid while this call is in progress. + - OCI_SUCCESS means the current call is completed. User is free to + execute OCIStmt*, OCILob*, etc. from the same service context. + - OCI_ERROR means this call encounters some errors. Use OCIErrorGet to + obtain information about the error. +*/ +sword OCIXStreamInLCRSend( + OCISvcCtx *svchp, + OCIError *errhp, + void *lcrp, + ub1 lcrtype, + oraub8 flag, + ub4 mode); + +/*----------------------------- OCIXStreamInChunkSend -----------------------*/ +/* + NAME + OCIXStreamInChunkSend - Send Chunk + DESCRIPTION + Sends the given chunk of column data to XStream Inbound server. + This chunk is associated with the LCR that is sent by the + most recent OCIXStreamInLCRSend call prior to this call. + PARAMETERS + svchp (IN/OUT) - OCI service handle + errhp (IN/OUT) - Error Handle to which errors should be reported + column_name (IN) - Name of column for which data is sent. + Column names must be canonicalized and must + follow Oracle naming conventions. + column_name_len (IN) - Length of column name. + column_dty (IN) - LCR column data type (must be SQLT_CHR or + SQLT_BIN). + column_flag (IN) - LCR column flags. Possible bit values are + OCI_LCR_COLUMN_LOB_DATA + OCI_LCR_COLUMN_LONG_DATA + OCI_LCR_COLUMN_EMPTY_LOB + OCI_LCR_COLUMN_LAST_CHUNK + OCI_LCR_COLUMN_AL16UTF16 + OCI_LCR_COLUMN_ENCRYPTED + OCI_LCR_COLUMN_NCLOB + OCI_LCR_COLUMN_XML_DATA + OCI_LCR_COLUMN_XML_DIFF + column_csid (IN) - Column character set id. This is required only + if the column is an XMLType column (i.e., + column_flag has OCI_LCR_COLUMN_XML_DATA bit set). + chunk_bytes (IN) - Chunk data length in bytes. + chunk_data (IN) - Chunk data buffer. + flag (IN) - If OCI_XSTREAM_MORE_ROW_DATA is set, it means + the current LCR has more data coming. + mode (IN) - mode for future extension. (Not used currently). +RETURNS + OCI_SUCCESS - Successful call. + OCI_ERROR - Error encountered. Execute OCIErrorGet to get information + about the error. +NOTES + - This function must be called while OCIXStreamInLCRSend is in progress. + + - This function is valid only if the associated LCR's cmd type is + INSERT, UPDATE or LOB_WRITE. It can be invoked multiple times for the + same LCR. + + - This API is not valid for LOB_ERASE and LOB_TRIM LCRs. + + - The chunk values for different columns can not be interleaved. If a + column contains multiple chunks, this procedure must be called + consecutively using the same column name before proceeding to a new column. + The ordering in which the LOB/LONG/XMLType column values are set is + irrelevant. + + - The OCI_LCR_COLUMN_LAST_CHUNK must be specified for the last chunk of + each column. + + - Only one column can be specified for LOB_WRITE operation. + + - For NCLOB or varying width CLOB, the input buffer must be in + AL16UTF16 format. + + - For INSERT operation, each LOB/LONG/XMLType column, with value set using + OCIXStreamInChunkSend, must be included in the current LCR's NEW + column list. The value of that LOB/LONG/XMLType column must be set to + null and must have OCI_LCR_COLUMN_EMPTY_LOB flag defined. + +*/ +sword OCIXStreamInChunkSend (OCISvcCtx *svchp, OCIError *errhp, + oratext *column_name, ub2 column_name_len, + ub2 column_dty, oraub8 column_flag, + ub2 column_csid, ub4 chunk_bytes, + ub1 *chunk_data, oraub8 flag, ub4 mode); + +/*--------------------- OCIXStreamInDetach ----------------------------*/ +/* + NAME + OCIXStreamInDetach - OCI XStream In Detach from Inbound Server + DESCRIPTION + Detaches from XStream inbound server and returns the inbound server's + processed low-watermark. + PARAMETERS + svchp (IN/OUT) - OCI service handle + errhp (IN/OUT) - Error Handle to which errors + should be reported + processed_low_position (OUT) - Inbound server's processed low + position. Must pre-allocate + OCI_LCR_MAX_POSITION_LEN bytes for + output buffer. + processed_low_position_len(OUT)- Processed_low_position length. + mode (IN) - Mode flags (For future extension. + Not used currently) + RETURNS + OCI_SUCCESS or OCI_ERROR. + NOTES + None +*/ +sword OCIXStreamInDetach( + OCISvcCtx *svchp, + OCIError *errhp, + ub1 *processed_low_position, + ub2 *processed_low_position_len, + ub4 mode); + +/*--------------------- OCIXStreamInProcessedLWMGet -------------------------*/ +/* + NAME + OCIXStreamInProcessedLWMGet - OCI XStream In Get LowWatermark + DESCRIPTION + Returns XStream inbound server's processed low watermark + cached at the client. + PARAMETERS + svchp (IN/OUT) - OCI service handle + errhp (IN/OUT) - Error Handle to which errors + should be reported + processed_low_position (OUT) - Inbound server's cached processed + low position. Must pre- + allocate OCI_LCR_MAX_POSITION_LEN + bytes for output buffer. + processed_low_position_len (OUT) - Processed_low_position length. + mode (IN) - Mode flags (For future extension. + Not used currently) + RETURNS + OCI_SUCCESS or OCI_ERROR. + NOTES + None +*/ +sword OCIXStreamInProcessedLWMGet( + OCISvcCtx *svchp, + OCIError *errhp, + ub1 *processed_low_position, + ub2 *processed_low_position_len, + ub4 mode); + +/*-------------------------- OCIXStreamInFlush ------------------------------*/ +/* + NAME + OCIXStreamInFlush - OCI XStream In Flush network + DESCRIPTION + Flushes network and terminates any in-progress OCIXStreamInLCRSend or + OCIXStreamInLCRCallbackSend call associated with the given service handle. + PARAMETERS + svchp (IN/OUT) - OCI service handle + errhp (IN/OUT) - Error Handle to which errors + should be reported + mode (IN) - Mode flags (For future extension. + Not used currently) + RETURNS + OCI_SUCCESS or OCI_ERROR. + NOTES + Each call will incur a database round trip to get the server's processed + low-watermark, which the user can retrieve afterward using + OCIXStreamInProcessedLWMGet API. This API should be called only when + there is no LCR to send to the server and the client wants to know the + progress of the attached inbound server. + + This call returns OCI_ERROR if it is invoked from the callback functions + of OCIXStreamInLCRCallbackSend API. + + Client must have attached to an XStream inbound server prior to calling + this API. +*/ +sword OCIXStreamInFlush( + OCISvcCtx *svchp, + OCIError *errhp, + ub4 mode); + +/*--------------------------------------------------------------------------- + INTERNAL FUNCTIONS + ---------------------------------------------------------------------------*/ + + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif /* OCIXSTREAM_ORACLE */ diff --git a/OCI/include/odci.h b/OCI/include/odci.h new file mode 100644 index 0000000..0395f96 --- /dev/null +++ b/OCI/include/odci.h @@ -0,0 +1,798 @@ +/* + * + */ + +/* Copyright (c) 1998, 2006, Oracle. All rights reserved. */ + +/* + NAME + odci.h - Oracle Data Cartridge Interface definitions + + DESCRIPTION + This file contains Oracle Data Cartridge Interface definitions. These + include the ODCI Types and Constants. + + RELATED DOCUMENTS + + INSPECTION STATUS + Inspection date: + Inspection status: + Estimated increasing cost defects per page: + Rule sets: + + ACCEPTANCE REVIEW STATUS + Review date: + Review status: + Reviewers: + + PUBLIC FUNCTION(S) + None. + + PRIVATE FUNCTION(S) + None. + + EXAMPLES + + NOTES + - The constants defined here are replica of the constants defined + in ODCIConst Package defined as part of catodci.sql. If you change + these do make the similar change in catodci.sql. + + MODIFIED (MM/DD/YY) + spsundar 09/13/07 - + yhu 06/02/06 - add callproperty for statistics + yhu 05/22/06 - add ODCI_NODATA to speed rebuild empty index or ind. + part. + srirkris 05/09/06 - change ODCIOrderByInfo_ind + srirkris 02/06/06 - add definitions for CDI query. + spsundar 02/17/06 - add fields/types for system managed domain idx + yhu 02/08/06 - add RenameCol Na d RenameTopADT + yhu 03/11/05 - add flags for rename column and rename table + spsundar 11/28/05 - add fields/types for composite domain idx + yhu 12/06/05 - mapping table for local text indexes + dmukhin 06/29/05 - ANSI prototypes; miscellaneous cleanup + ayoaz 04/21/03 - add CursorNum to ODCIEnv + abrumm 12/30/02 - Bug #2223225: add define for + ODCI_ARG_DESC_LIST_MAXSIZE + ayoaz 10/14/02 - Add Cardinality to ODCIArgDesc + ayoaz 09/11/02 - add ODCIQueryInfo to ODCIIndexCtx + yhu 09/19/02 - add ODCI_DEBUGGING_ON for ODCIEnv.EnvFlags + hsbedi 10/10/02 - add object number into ODCIExtTableInfo + ayoaz 08/30/02 - add ODCITable2 types + tchorma 07/29/02 - Add ODCIFuncCallInfo type for WITH COLUMN CONTEXT + hsbedi 06/29/02 - External table populate + yhu 07/20/01 - add parallel degree in ODCIIndexInfo. + abrumm 02/20/01 - ODCIExtTableInfo: add AccessParmBlob attribute + abrumm 01/18/01 - ODCIExtTableInfo: add default directory + spsundar 08/24/00 - Update attrbiute positions + abrumm 08/04/00 - external tables changes: ODCIExtTableInfo, constants + tchorma 09/11/00 - Add return code ODCI_FATAL + tchorma 08/08/00 - Add Update Block References Option for Alter Index + ayoaz 08/01/00 - Add ODCI_AGGREGATE_REUSE_CTX + spsundar 06/19/00 - add ODCIEnv type + abrumm 06/27/00 - add defines for ODCIExtTable flags + abrumm 06/04/00 - external tables: ODCIExtTableInfo change; add ODCIEnv + ddas 04/28/00 - extensible optimizer enhancements for 8.2 + yhu 06/05/00 - add a bit in IndexInfoFlags for trans. tblspc + yhu 04/10/00 - add ODCIPartInfo & remove ODCIIndexPartList + abrumm 03/29/00 - external table support + spsundar 02/14/00 - update odci definitions for 8.2 + nagarwal 03/07/99 - bug# 838308 - set estimate_stats=1 + rmurthy 11/09/98 - add blocking flag + ddas 10/31/98 - add ODCI_QUERY_SORT_ASC and ODCI_QUERY_SORT_DESC + ddas 05/26/98 - fix ODCIPredInfo flag bits + rmurthy 06/03/98 - add macro for RegularCall + spsundar 05/08/98 - add constants related to ODCIIndexAlter options + rmurthy 04/30/98 - remove include s.h + rmurthy 04/20/98 - name fixes + rmurthy 04/13/98 - add C mappings for odci types + alsrivas 04/10/98 - adding defines for ODCI_INDEX1 + jsriniva 04/04/98 - Creation + +*/ + +#ifndef OCI_ORACLE +# include +#endif +#ifndef ODCI_ORACLE +# define ODCI_ORACLE + +/*---------------------------------------------------------------------------*/ +/* SHORT NAMES SUPPORT SECTION */ +/*---------------------------------------------------------------------------*/ + +#ifdef SLSHORTNAME + +/* The following are short names that are only supported on IBM mainframes + * with the SLSHORTNAME defined. + * With this all subsequent long names will actually be substituted with + * the short names here + */ + +#define ODCIColInfo_ref odcicir +#define ODCIColInfoList odcicil +#define ODCIColInfoList2 odcicil2 +#define ODCIIndexInfo_ref odciiir +#define ODCIPredInfo_ref odcipir +#define ODCIRidList odcirl +#define ODCIIndexCtx_ref odciicr +#define ODCIObject_ref odcior +#define ODCIObjectList odciol +#define ODCIQueryInfo_ref odciqir +#define ODCIFuncInfo_ref odcifir +#define ODCICost_ref odcicr +#define ODCIArgDesc_ref odciadr +#define ODCIArgDescList odciadl +#define ODCIStatsOptions_ref odcisor +#define ODCIColInfo odcici +#define ODCIColInfo_ind odcicii +#define ODCIIndexInfo odciii +#define ODCIIndexInfo_ind odciiii +#define ODCIPredInfo odcipi +#define ODCIPredInfo_ind odcipii +#define ODCIIndexCtx odciic +#define ODCIIndexCtx_ind odciici +#define ODCIObject odcio +#define ODCIObject_ind odcioi +#define ODCIQueryInfo odciqi +#define ODCIQueryInfo_ind odciqii +#define ODCIFuncInfo odcifi +#define ODCIFuncInfo_infd odcifii +#define ODCICost odcic +#define ODCICost_ind odcici +#define ODCIArgDesc odciad +#define ODCIArgDesc_ind odciadi +#define ODCIStatsOptions odciso +#define ODCIStatsOptions_ind odcisoi +#define ODCIPartInfo odcipti +#define ODCIPartInfo_ind odciptii +#define ODCIPartInfo_ref odciptir +#define ODCIExtTableInfo odcixt +#define ODCIExtTableInfo_ind odcixti +#define ODCIExtTableInfo_ref odcixtr +#define ODCIExtTableQCInfo odcixq +#define ODCIExtTableQCInfo_ind odcixqi +#define ODCIExtTableQCInfo_ref odcixqr +#define ODCIFuncCallInfo odcifc +#define ODCIFuncCall_ind odcifci +#define ODCIFuncCall_ref odcifcr +#define ODCIColValList odcicvl +#define ODCIColArrayList odcical +#define ODCIFilterInfoList odciflil +#define ODCIOrderByInfoList odciobil +#define ODCIFilterInfo_ref odciflir +#define ODCIOrderByInfo_ref odciobir +#define ODCICompQueryInfo_ref odcicqir +#define ODCIFilterInfo odcifli +#define ODCIOrderByInfo odciobi +#define ODCICompQueryInfo odcicqi +#define ODCIFilterInfo_ind odciflii +#define ODCIOrderByInfo_ind odciobii +#define ODCICompQueryInfo_ind odcicqii + +#endif /* SLSHORTNAME */ + +/*--------------------------------------------------------------------------- + PUBLIC TYPES AND CONSTANTS + ---------------------------------------------------------------------------*/ + +/* Constants for Return Status */ +#define ODCI_SUCCESS 0 +#define ODCI_ERROR 1 +#define ODCI_WARNING 2 +#define ODCI_ERROR_CONTINUE 3 +#define ODCI_FATAL 4 + +/* Constants for ODCIPredInfo.Flags */ +#define ODCI_PRED_EXACT_MATCH 0x0001 +#define ODCI_PRED_PREFIX_MATCH 0x0002 +#define ODCI_PRED_INCLUDE_START 0x0004 +#define ODCI_PRED_INCLUDE_STOP 0x0008 +#define ODCI_PRED_OBJECT_FUNC 0x0010 +#define ODCI_PRED_OBJECT_PKG 0x0020 +#define ODCI_PRED_OBJECT_TYPE 0x0040 +#define ODCI_PRED_MULTI_TABLE 0x0080 +#define ODCI_PRED_NOT_EQUAL 0x0100 + +/* Constants for QueryInfo.Flags */ +#define ODCI_QUERY_FIRST_ROWS 0x01 +#define ODCI_QUERY_ALL_ROWS 0x02 +#define ODCI_QUERY_SORT_ASC 0x04 +#define ODCI_QUERY_SORT_DESC 0x08 +#define ODCI_QUERY_BLOCKING 0x10 + +/* Constants for ScnFlg(Func /w Index Context) */ +#define ODCI_CLEANUP_CALL 1 +#define ODCI_REGULAR_CALL 2 + +/* Constants for ODCIFuncInfo.Flags */ +#define ODCI_OBJECT_FUNC 0x01 +#define ODCI_OBJECT_PKG 0x02 +#define ODCI_OBJECT_TYPE 0x04 + +/* Constants for ODCIArgDesc.ArgType */ +#define ODCI_ARG_OTHER 1 +#define ODCI_ARG_COL 2 /* column */ +#define ODCI_ARG_LIT 3 /* literal */ +#define ODCI_ARG_ATTR 4 /* object attribute */ +#define ODCI_ARG_NULL 5 +#define ODCI_ARG_CURSOR 6 + +/* Maximum size of ODCIArgDescList array */ +#define ODCI_ARG_DESC_LIST_MAXSIZE 32767 + +/* Constants for ODCIStatsOptions.Options */ +#define ODCI_PERCENT_OPTION 1 +#define ODCI_ROW_OPTION 2 + +/* Constants for ODCIStatsOptions.Flags */ +#define ODCI_ESTIMATE_STATS 0x01 +#define ODCI_COMPUTE_STATS 0x02 +#define ODCI_VALIDATE 0x04 + +/* Constants for ODCIIndexAlter parameter alter_option */ +#define ODCI_ALTIDX_NONE 0 +#define ODCI_ALTIDX_RENAME 1 +#define ODCI_ALTIDX_REBUILD 2 +#define ODCI_ALTIDX_REBUILD_ONL 3 +#define ODCI_ALTIDX_MODIFY_COL 4 +#define ODCI_ALTIDX_UPDATE_BLOCK_REFS 5 +#define ODCI_ALTIDX_RENAME_COL 6 +#define ODCI_ALTIDX_RENAME_TAB 7 +#define ODCI_ALTIDX_MIGRATE 8 + +/* Constants for ODCIIndexInfo.IndexInfoFlags */ +#define ODCI_INDEX_LOCAL 0x0001 +#define ODCI_INDEX_RANGE_PARTN 0x0002 +#define ODCI_INDEX_HASH_PARTN 0x0004 +#define ODCI_INDEX_ONLINE 0x0008 +#define ODCI_INDEX_PARALLEL 0x0010 +#define ODCI_INDEX_UNUSABLE 0x0020 +#define ODCI_INDEX_ONIOT 0x0040 +#define ODCI_INDEX_TRANS_TBLSPC 0x0080 +#define ODCI_INDEX_FUNCTION_IDX 0x0100 +#define ODCI_INDEX_LIST_PARTN 0x0200 + +/* Constants for ODCIIndexInfo.IndexParaDegree */ +#define ODCI_INDEX_DEFAULT_DEGREE 32767 + +/* Constants for ODCIEnv.EnvFlags */ +#define ODCI_DEBUGGING_ON 0x01 +#define ODCI_NODATA 0x02 + +/* Constants for ODCIEnv.CallProperty */ +#define ODCI_CALL_NONE 0 +#define ODCI_CALL_FIRST 1 +#define ODCI_CALL_INTERMEDIATE 2 +#define ODCI_CALL_FINAL 3 +#define ODCI_CALL_REBUILD_INDEX 4 +#define ODCI_CALL_REBUILD_PMO 5 +#define ODCI_CALL_STATSGLOBAL 6 +#define ODCI_CALL_STATSGLOBALANDPARTITION 7 +#define ODCI_CALL_STATSPARTITION 8 + +/* Constants for ODCIExtTableInfo.OpCode */ +#define ODCI_EXTTABLE_INFO_OPCODE_FETCH 1 +#define ODCI_EXTTABLE_INFO_OPCODE_POPULATE 2 + +/* Constants (bit definitions) for ODCIExtTableInfo.Flag */ + /* sampling type: row or block */ +#define ODCI_EXTTABLE_INFO_FLAG_SAMPLE 0x00000001 +#define ODCI_EXTTABLE_INFO_FLAG_SAMPLE_BLOCK 0x00000002 + /* AccessParmClob, AccessParmBlob discriminator */ +#define ODCI_EXTTABLE_INFO_FLAG_ACCESS_PARM_CLOB 0x00000004 +#define ODCI_EXTTABLE_INFO_FLAG_ACCESS_PARM_BLOB 0x00000008 + +/* Constants for ODCIExtTableInfo.IntraSourceConcurrency */ +#define ODCI_TRUE 1 +#define ODCI_FALSE 0 + +/* Constants (bit definitions) for ODCIExtTable{Open,Fetch,Populate,Close} + * Flag argument. + */ +#define ODCI_EXTTABLE_OPEN_FLAGS_QC 0x00000001 /* caller is Query Coord */ +#define ODCI_EXTTABLE_OPEN_FLAGS_SHADOW 0x00000002 /* caller is shadow proc */ +#define ODCI_EXTTABLE_OPEN_FLAGS_SLAVE 0x00000004 /* caller is slave proc */ + +#define ODCI_EXTTABLE_FETCH_FLAGS_EOS 0x00000001 /* end-of-stream on fetch */ + +/* Constants for Flags argument to ODCIAggregateTerminate */ +#define ODCI_AGGREGATE_REUSE_CTX 1 + +/* Constants for ODCIColInfo.Flags */ +#define ODCI_COMP_FILTERBY_COL 0x0001 +#define ODCI_COMP_ORDERBY_COL 0x0002 +#define ODCI_COMP_ORDERDSC_COL 0x0004 +#define ODCI_COMP_UPDATED_COL 0x0008 +#define ODCI_COMP_RENAMED_COL 0x0010 +#define ODCI_COMP_RENAMED_TOPADT 0x0020 + +/* Constants for ODCIOrderByInfo.ExprType */ +#define ODCI_COLUMN_EXPR 1 +#define ODCI_ANCOP_EXPR 2 + +/* Constants for ODCIOrderByInfo.SortOrder */ +#define ODCI_SORT_ASC 1 +#define ODCI_SORT_DESC 2 +#define ODCI_NULLS_FIRST 4 + +/* Constants for ODCIPartInfo.PartOp */ +#define ODCI_ADD_PARTITION 1 +#define ODCI_DROP_PARTITION 2 + +/*--------------------------------------------------------------------------- + ODCI TYPES + ---------------------------------------------------------------------------*/ +/* + * These are C mappings for the OTS types defined in catodci.sql + */ + +typedef OCIRef ODCIColInfo_ref; +typedef OCIArray ODCIColInfoList; +typedef OCIArray ODCIColInfoList2; +typedef OCIRef ODCIIndexInfo_ref; +typedef OCIRef ODCIPredInfo_ref; +typedef OCIArray ODCIRidList; +typedef OCIRef ODCIIndexCtx_ref; +typedef OCIRef ODCIObject_ref; +typedef OCIArray ODCIObjectList; +typedef OCIRef ODCIQueryInfo_ref; +typedef OCIRef ODCIFuncInfo_ref; +typedef OCIRef ODCICost_ref; +typedef OCIRef ODCIArgDesc_ref; +typedef OCIArray ODCIArgDescList; +typedef OCIRef ODCIStatsOptions_ref; +typedef OCIRef ODCIPartInfo_ref; +typedef OCIRef ODCIEnv_ref; +typedef OCIRef ODCIExtTableInfo_ref; /* external table support */ +typedef OCIArray ODCIGranuleList; /* external table support */ +typedef OCIRef ODCIExtTableQCInfo_ref; /* external table support */ +typedef OCIRef ODCIFuncCallInfo_ref; +typedef OCIArray ODCINumberList; +typedef OCIArray ODCIPartInfoList; +typedef OCIArray ODCIColValList; +typedef OCIArray ODCIColArrayList; +typedef OCIArray ODCIFilterInfoList; +typedef OCIArray ODCIOrderByInfoList; +typedef OCIRef ODCIFilterInfo_ref; +typedef OCIRef ODCIOrderByInfo_ref; +typedef OCIRef ODCICompQueryInfo_ref; + +struct ODCIColInfo +{ + OCIString* TableSchema; + OCIString* TableName; + OCIString* ColName; + OCIString* ColTypName; + OCIString* ColTypSchema; + OCIString* TablePartition; + OCINumber ColFlags; + OCINumber ColOrderPos; + OCINumber TablePartitionIden; + OCINumber TablePartitionTotal; +}; +typedef struct ODCIColInfo ODCIColInfo; + +struct ODCIColInfo_ind +{ + OCIInd atomic; + OCIInd TableSchema; + OCIInd TableName; + OCIInd ColName; + OCIInd ColTypName; + OCIInd ColTypSchema; + OCIInd TablePartition; + OCIInd ColFlags; + OCIInd ColOrderPos; + OCIInd TablePartitionIden; + OCIInd TablePartitionTotal; +}; +typedef struct ODCIColInfo_ind ODCIColInfo_ind; + +struct ODCIFuncCallInfo +{ + struct ODCIColInfo ColInfo; +}; + +struct ODCIFuncCallInfo_ind +{ + struct ODCIColInfo_ind ColInfo; +}; + +struct ODCIIndexInfo +{ + OCIString* IndexSchema; + OCIString* IndexName; + ODCIColInfoList* IndexCols; + OCIString* IndexPartition; + OCINumber IndexInfoFlags; + OCINumber IndexParaDegree; + OCINumber IndexPartitionIden; + OCINumber IndexPartitionTotal; +}; +typedef struct ODCIIndexInfo ODCIIndexInfo; + +struct ODCIIndexInfo_ind +{ + OCIInd atomic; + OCIInd IndexSchema; + OCIInd IndexName; + OCIInd IndexCols; + OCIInd IndexPartition; + OCIInd IndexInfoFlags; + OCIInd IndexParaDegree; + OCIInd IndexPartitionIden; + OCIInd IndexPartitionTotal; +}; +typedef struct ODCIIndexInfo_ind ODCIIndexInfo_ind; + +struct ODCIPredInfo +{ + OCIString* ObjectSchema; + OCIString* ObjectName; + OCIString* MethodName; + OCINumber Flags; +}; +typedef struct ODCIPredInfo ODCIPredInfo; + +struct ODCIPredInfo_ind +{ + OCIInd atomic; + OCIInd ObjectSchema; + OCIInd ObjectName; + OCIInd MethodName; + OCIInd Flags; +}; +typedef struct ODCIPredInfo_ind ODCIPredInfo_ind; + +struct ODCIFilterInfo +{ + ODCIColInfo ColInfo; + OCINumber Flags; + OCIAnyData *strt; + OCIAnyData *stop; +}; +typedef struct ODCIFilterInfo ODCIFilterInfo; + +struct ODCIFilterInfo_ind +{ + OCIInd atomic; + ODCIColInfo_ind ColInfo; + OCIInd Flags; + OCIInd strt; + OCIInd stop; +}; +typedef struct ODCIFilterInfo_ind ODCIFilterInfo_ind; + + +struct ODCIOrderByInfo +{ + OCINumber ExprType; + OCIString *ObjectSchema; + OCIString *TableName; + OCIString *ExprName; + OCINumber SortOrder; +}; +typedef struct ODCIOrderByInfo ODCIOrderByInfo; + +struct ODCIOrderByInfo_ind +{ + OCIInd atomic; + OCIInd ExprType; + OCIInd ObjectSchema; + OCIInd TableName; + OCIInd ExprName; + OCIInd SortOrder; +}; +typedef struct ODCIOrderByInfo_ind ODCIOrderByInfo_ind; + + +struct ODCICompQueryInfo +{ + ODCIFilterInfoList *PredInfo; + ODCIOrderByInfoList *ObyInfo; +}; +typedef struct ODCICompQueryInfo ODCICompQueryInfo; + +struct ODCICompQueryInfo_ind +{ + OCIInd atomic; + OCIInd PredInfo; + OCIInd ObyInfo; +}; +typedef struct ODCICompQueryInfo_ind ODCICompQueryInfo_ind; + + +struct ODCIObject +{ + OCIString* ObjectSchema; + OCIString* ObjectName; +}; +typedef struct ODCIObject ODCIObject; + +struct ODCIObject_ind +{ + OCIInd atomic; + OCIInd ObjectSchema; + OCIInd ObjectName; +}; +typedef struct ODCIObject_ind ODCIObject_ind; + +struct ODCIQueryInfo +{ + OCINumber Flags; + ODCIObjectList* AncOps; + ODCICompQueryInfo CompInfo; +}; +typedef struct ODCIQueryInfo ODCIQueryInfo; + + +struct ODCIQueryInfo_ind +{ + OCIInd atomic; + OCIInd Flags; + OCIInd AncOps; + ODCICompQueryInfo_ind CompInfo; +}; +typedef struct ODCIQueryInfo_ind ODCIQueryInfo_ind; + +struct ODCIIndexCtx +{ + struct ODCIIndexInfo IndexInfo; + OCIString* Rid; + struct ODCIQueryInfo QueryInfo; +}; +typedef struct ODCIIndexCtx ODCIIndexCtx; + +struct ODCIIndexCtx_ind +{ + OCIInd atomic; + struct ODCIIndexInfo_ind IndexInfo; + OCIInd Rid; + struct ODCIQueryInfo_ind QueryInfo; +}; +typedef struct ODCIIndexCtx_ind ODCIIndexCtx_ind; + +struct ODCIFuncInfo +{ + OCIString* ObjectSchema; + OCIString* ObjectName; + OCIString* MethodName; + OCINumber Flags; +}; +typedef struct ODCIFuncInfo ODCIFuncInfo; + +struct ODCIFuncInfo_ind +{ + OCIInd atomic; + OCIInd ObjectSchema; + OCIInd ObjectName; + OCIInd MethodName; + OCIInd Flags; +}; +typedef struct ODCIFuncInfo_ind ODCIFuncInfo_ind; + +struct ODCICost +{ + OCINumber CPUcost; + OCINumber IOcost; + OCINumber NetworkCost; + OCIString* IndexCostInfo; +}; +typedef struct ODCICost ODCICost; + +struct ODCICost_ind +{ + OCIInd atomic; + OCIInd CPUcost; + OCIInd IOcost; + OCIInd NetworkCost; + OCIInd IndexCostInfo; +}; +typedef struct ODCICost_ind ODCICost_ind; + +struct ODCIArgDesc +{ + OCINumber ArgType; + OCIString* TableName; + OCIString* TableSchema; + OCIString* ColName; + OCIString* TablePartitionLower; + OCIString* TablePartitionUpper; + OCINumber Cardinality; +}; +typedef struct ODCIArgDesc ODCIArgDesc; + +struct ODCIArgDesc_ind +{ + OCIInd atomic; + OCIInd ArgType; + OCIInd TableName; + OCIInd TableSchema; + OCIInd ColName; + OCIInd TablePartitionLower; + OCIInd TablePartitionUpper; + OCIInd Cardinality; +}; +typedef struct ODCIArgDesc_ind ODCIArgDesc_ind; + +struct ODCIStatsOptions +{ + OCINumber Sample; + OCINumber Options; + OCINumber Flags; +}; +typedef struct ODCIStatsOptions ODCIStatsOptions; + +struct ODCIStatsOptions_ind +{ + OCIInd atomic; + OCIInd Sample; + OCIInd Options; + OCIInd Flags; +}; +typedef struct ODCIStatsOptions_ind ODCIStatsOptions_ind; + +struct ODCIEnv +{ + OCINumber EnvFlags; + OCINumber CallProperty; + OCINumber DebugLevel; + OCINumber CursorNum; +}; +typedef struct ODCIEnv ODCIEnv; + +struct ODCIEnv_ind +{ + OCIInd _atomic; + OCIInd EnvFlags; + OCIInd CallProperty; + OCIInd DebugLevel; + OCIInd CursorNum; +}; +typedef struct ODCIEnv_ind ODCIEnv_ind; + +struct ODCIPartInfo +{ + OCIString* TablePartition; + OCIString* IndexPartition; + OCINumber IndexPartitionIden; + OCINumber PartOp; +}; +typedef struct ODCIPartInfo ODCIPartInfo; + +struct ODCIPartInfo_ind +{ + OCIInd atomic; + OCIInd TablePartition; + OCIInd IndexPartition; + OCIInd IndexPartitionIden; + OCIInd PartOp; +}; +typedef struct ODCIPartInfo_ind ODCIPartInfo_ind; + +/*---------- External Tables ----------*/ +struct ODCIExtTableInfo +{ + OCIString* TableSchema; + OCIString* TableName; + ODCIColInfoList* RefCols; + OCIClobLocator* AccessParmClob; + OCIBlobLocator* AccessParmBlob; + ODCIArgDescList* Locations; + ODCIArgDescList* Directories; + OCIString* DefaultDirectory; + OCIString* DriverType; + OCINumber OpCode; + OCINumber AgentNum; + OCINumber GranuleSize; + OCINumber Flag; + OCINumber SamplePercent; + OCINumber MaxDoP; + OCIRaw* SharedBuf; + OCIString* MTableName; + OCIString* MTableSchema; + OCINumber TableObjNo; +}; +typedef struct ODCIExtTableInfo ODCIExtTableInfo; + +struct ODCIExtTableInfo_ind +{ + OCIInd _atomic; + OCIInd TableSchema; + OCIInd TableName; + OCIInd RefCols; + OCIInd AccessParmClob; + OCIInd AccessParmBlob; + OCIInd Locations; + OCIInd Directories; + OCIInd DefaultDirectory; + OCIInd DriverType; + OCIInd OpCode; + OCIInd AgentNum; + OCIInd GranuleSize; + OCIInd Flag; + OCIInd SamplePercent; + OCIInd MaxDoP; + OCIInd SharedBuf; + OCIInd MTableName; + OCIInd MTableSchema; + OCIInd TableObjNo; +}; +typedef struct ODCIExtTableInfo_ind ODCIExtTableInfo_ind; + +struct ODCIExtTableQCInfo +{ + OCINumber NumGranules; + OCINumber NumLocations; + ODCIGranuleList* GranuleInfo; + OCINumber IntraSourceConcurrency; + OCINumber MaxDoP; + OCIRaw* SharedBuf; +}; +typedef struct ODCIExtTableQCInfo ODCIExtTableQCInfo; + +struct ODCIExtTableQCInfo_ind +{ + OCIInd _atomic; + OCIInd NumGranules; + OCIInd NumLocations; + OCIInd GranuleInfo; + OCIInd IntraSourceConcurrency; + OCIInd MaxDoP; + OCIInd SharedBuf; +}; +typedef struct ODCIExtTableQCInfo_ind ODCIExtTableQCInfo_ind; + +/*********************************************************/ +/* Table Function Info types (used by ODCITablePrepare) */ +/*********************************************************/ + +struct ODCITabFuncInfo +{ + ODCINumberList* Attrs; + OCIType* RetType; +}; +typedef struct ODCITabFuncInfo ODCITabFuncInfo; + +struct ODCITabFuncInfo_ind +{ + OCIInd _atomic; + OCIInd Attrs; + OCIInd RetType; +}; +typedef struct ODCITabFuncInfo_ind ODCITabFuncInfo_ind; + +/*********************************************************************/ +/* Table Function Statistics types (used by ODCIStatsTableFunction) */ +/*********************************************************************/ + +struct ODCITabFuncStats +{ + OCINumber num_rows; +}; +typedef struct ODCITabFuncStats ODCITabFuncStats; + +struct ODCITabFuncStats_ind +{ + OCIInd _atomic; + OCIInd num_rows; +}; +typedef struct ODCITabFuncStats_ind ODCITabFuncStats_ind; + +/*--------------------------------------------------------------------------- + PRIVATE TYPES AND CONSTANTS + ---------------------------------------------------------------------------*/ + + +/*--------------------------------------------------------------------------- + PUBLIC FUNCTIONS + ---------------------------------------------------------------------------*/ + + +/*--------------------------------------------------------------------------- + PRIVATE FUNCTIONS + ---------------------------------------------------------------------------*/ + + +#endif /* ODCI_ORACLE */ diff --git a/OCI/include/oratypes.h b/OCI/include/oratypes.h new file mode 100644 index 0000000..03e6e59 --- /dev/null +++ b/OCI/include/oratypes.h @@ -0,0 +1,322 @@ +/* + Copyright (c) 1982, 2008, Oracle and/or its affiliates.All rights reserved. +*/ + +/* + * $Header: oracore3/public/oratypes.h /nt/21 2009/01/01 19:48:06 sabchoud Exp $ + */ + + + +#ifndef ORATYPES +# define ORATYPES +# define SX_ORACLE +# define SX3_ORACLE + + +#ifndef ORASTDDEF +# include +# define ORASTDDEF +#endif + +#ifndef ORALIMITS +# include +# define ORALIMITS +#endif + + +#ifndef TRUE +# define TRUE 1 +# define FALSE 0 +#endif + + +#ifndef lint +typedef unsigned char ub1; +typedef signed char sb1; +#else +#define ub1 unsigned char +#define sb1 signed char +#endif + +#define UB1MAXVAL ((ub1)UCHAR_MAX) +#define UB1MINVAL ((ub1) 0) +#define SB1MAXVAL ((sb1)SCHAR_MAX) +#define SB1MINVAL ((sb1)SCHAR_MIN) +#define MINUB1MAXVAL ((ub1) 255) +#define MAXUB1MINVAL ((ub1) 0) +#define MINSB1MAXVAL ((sb1) 127) +#define MAXSB1MINVAL ((sb1) -127) + + + + +#ifndef lint +typedef unsigned short ub2; +typedef signed short sb2; +#else +#define ub2 unsigned short +#define sb2 signed short +#endif + +#define UB2MAXVAL ((ub2)USHRT_MAX) +#define UB2MINVAL ((ub2) 0) +#define SB2MAXVAL ((sb2) SHRT_MAX) +#define SB2MINVAL ((sb2) SHRT_MIN) +#define MINUB2MAXVAL ((ub2) 65535) +#define MAXUB2MINVAL ((ub2) 0) +#define MINSB2MAXVAL ((sb2) 32767) +#define MAXSB2MINVAL ((sb2)-32767) + + + + +#ifndef lint +typedef unsigned int ub4; +typedef signed int sb4; +#else +#define eb4 int +#define ub4 unsigned int +#define sb4 signed int +#endif + +#define UB4MAXVAL ((ub4)UINT_MAX) +#define UB4MINVAL ((ub4) 0) +#define SB4MAXVAL ((sb4) INT_MAX) +#define SB4MINVAL ((sb4) INT_MIN) +#define MINUB4MAXVAL ((ub4) 4294967295) +#define MAXUB4MINVAL ((ub4) 0) +#define MINSB4MAXVAL ((sb4) 2147483647) +#define MAXSB4MINVAL ((sb4)-2147483647) + + +/* --- Signed/Unsigned eight-byte scalar (orasb8/oraub8) --- */ + +#define ORAXB8_DEFINED +#ifndef lint +#ifndef __GNUC__ +#ifdef __BORLANDC__ + typedef unsigned __int64 oraub8; + typedef signed __int64 orasb8; +#else + typedef unsigned _int64 oraub8; + typedef signed _int64 orasb8; +#endif /* __BORLANDC__ */ +#else + typedef unsigned long long oraub8; + typedef signed long long orasb8; +#endif + typedef oraub8 ub8; + typedef orasb8 sb8; +#else +# define ub8 oraub8 +# define sb8 orasb8 +# define oraub8 unsigned _int64 +# define orasb8 signed _int64 +#endif /* !lint */ + +#define ORAUB8MINVAL ((oraub8)0) +#define ORAUB8MAXVAL ((oraub8)18446744073709551615) +#define ORASB8MINVAL ((orasb8)-9223372036854775808) +#define ORASB8MAXVAL ((orasb8) 9223372036854775807) + +#define MAXORAUB8MINVAL ((oraub8)0) +#define MINORAUB8MAXVAL ((oraub8)18446744073709551615) +#define MAXORASB8MINVAL ((orasb8)-9223372036854775807) +#define MINORASB8MAXVAL ((orasb8) 9223372036854775807) + + +#define UB1BITS CHAR_BIT +#define UB1MASK ((1 << ((uword)CHAR_BIT)) - 1) + + +#ifdef lint +# define oratext unsigned char +#else + typedef unsigned char oratext; +#endif + + +#ifndef lint +typedef char eb1; +typedef short eb2; +typedef int eb4; +#else +# define eb1 char +# define eb2 short +# define eb4 int +#endif + +#define EB1MAXVAL ((eb1)SCHAR_MAX) +#define EB1MINVAL ((eb1) 0) +#define MINEB1MAXVAL ((eb1) 127) +#define MAXEB1MINVAL ((eb1) 0) +#define EB2MAXVAL ((eb2) SHRT_MAX) +#define EB2MINVAL ((eb2) 0) +#define MINEB2MAXVAL ((eb2) 32767) +#define MAXEB2MINVAL ((eb2) 0) +#define EB4MAXVAL ((eb4) INT_MAX) +#define EB4MINVAL ((eb4) 0) +#define MINEB4MAXVAL ((eb4) 2147483647) +#define MAXEB4MINVAL ((eb4) 0) + + + + +#ifndef lint +typedef sb1 b1; +#else +#define b1 sb1 +#endif +#define B1MAXVAL SB1MAXVAL +#define B1MINVAL SB1MINVAL + +#ifndef lint +typedef sb2 b2; +#else +#define b2 sb2 +#endif +#define B2MAXVAL SB2MAXVAL +#define B2MINVAL SB2MINVAL + +#ifndef lint +typedef sb4 b4; +#else +#define b4 sb4 +#endif +# define B4MAXVAL SB4MAXVAL +# define B4MINVAL SB4MINVAL + + +#if !defined(LUSEMFC) +# ifdef lint +# define text unsigned char +# else + typedef oratext text; +# endif +#endif + +#ifdef lint +# define OraText unsigned char +#else + typedef oratext OraText; +#endif + +#ifndef lint +typedef int eword; +typedef unsigned int uword; +typedef signed int sword; +#else +#define eword int +#define uword unsigned int +#define sword signed int +#endif + +#define EWORDMAXVAL ((eword) INT_MAX) +#define EWORDMINVAL ((eword) 0) +#define UWORDMAXVAL ((uword)UINT_MAX) +#define UWORDMINVAL ((uword) 0) +#define SWORDMAXVAL ((sword) INT_MAX) +#define SWORDMINVAL ((sword) INT_MIN) +#define MINEWORDMAXVAL ((eword) 2147483647) +#define MAXEWORDMINVAL ((eword) 0) +#define MINUWORDMAXVAL ((uword) 4294967295) +#define MAXUWORDMINVAL ((uword) 0) +#define MINSWORDMAXVAL ((sword) 2147483647) +#define MAXSWORDMINVAL ((sword) -2147483647) + + +#ifdef _WIN64 + +#ifndef lint +#ifdef __BORLANDC__ +typedef unsigned __int64 ubig_ora; +typedef signed __int64 sbig_ora; +#else +typedef unsigned _int64 ubig_ora; +typedef signed _int64 sbig_ora; +#endif /* End of __BORLANDC__ */ +#else +#define ubig_ora unsigned _int64 +#define sbig_ora signed _int64 +#endif /* End of lint */ + +#define UBIG_ORAMAXVAL ((ubig_ora)_UI64_MAX) +#define UBIG_ORAMINVAL ((ubig_ora) 0) +#define SBIG_ORAMAXVAL ((sbig_ora) _I64_MAX) +#define SBIG_ORAMINVAL ((sbig_ora) _I64_MIN) +#define MINUBIG_ORAMAXVAL ((ubig_ora) 4294967295) +#define MAXUBIG_ORAMINVAL ((ubig_ora) 0) +#define MINSBIG_ORAMAXVAL ((sbig_ora) 2147483647) +#define MAXSBIG_ORAMINVAL ((sbig_ora)-2147483647) + +#else + +#ifndef lint +typedef unsigned long ubig_ora; +typedef signed long sbig_ora; +#else +#define ubig_ora unsigned long +#define sbig_ora signed long +#endif + +#define UBIG_ORAMAXVAL ((ubig_ora)ULONG_MAX) +#define UBIG_ORAMINVAL ((ubig_ora) 0) +#define SBIG_ORAMAXVAL ((sbig_ora) LONG_MAX) +#define SBIG_ORAMINVAL ((sbig_ora) LONG_MIN) +#define MINUBIG_ORAMAXVAL ((ubig_ora) 4294967295) +#define MAXUBIG_ORAMINVAL ((ubig_ora) 0) +#define MINSBIG_ORAMAXVAL ((sbig_ora) 2147483647) +#define MAXSBIG_ORAMINVAL ((sbig_ora)-2147483647) + +#endif /* _WIN64 */ + +#define UBIGORABITS (UB1BITS * sizeof(ubig_ora)) + + +#undef CONST +#define CONST const + + +#define dvoid void + + +typedef void (*lgenfp_t)( void ); + + + +#ifndef ORASYS_TYPES +# include +# define ORASYS_TYPES +#endif + + + +#ifndef boolean +# define boolean int +#endif + + + +#ifdef sparc +# define SIZE_TMAXVAL SB4MAXVAL +#else +# define SIZE_TMAXVAL UB4MAXVAL +#endif + +#define MINSIZE_TMAXVAL (size_t)4294967295 + + +#if !defined(MOTIF) && !defined(LISPL) && !defined(__cplusplus) && !defined(LUSEMFC) +typedef oratext *string; +#endif + +#ifndef lint +typedef unsigned short utext; +#else +#define utext unsigned short +#endif + + +#endif + diff --git a/OCI/include/ori.h b/OCI/include/ori.h new file mode 100644 index 0000000..60ea1b9 --- /dev/null +++ b/OCI/include/ori.h @@ -0,0 +1,2095 @@ +/* Copyright (c) 1994, 2006, Oracle. All rights reserved. */ + +/* + NAME + ORI - OCI navigational interface + + DESCRIPTION + + This section is intended to give a brief introduction to the navigational + interfaces. Readers can refer to the documents listed in the section + 'RELATED DOCUMENTS' for more information. + + PURPOSE + The Oracle Call Interface (OCI) supports navigational access of objects. + In the navigational paradigm, data is represented as a graph of objects + connected by references. Objects in the graph are reached by following + the references. + + OBJECT ENVIRONMENT + + The object environment is initialized when the OCI environment handle is + initialized with the object option. An object environment contains a + heap which buffers type instances in memory. The object environment also + contains an object cache which keeps track of the objects in the object + environment. Readers can refer to the "Functional Specification for + Programmatic Interface" for more information about the object + environment. + + INSTANCE, OBJECT AND VALUE + + An OTS instance is an occurence of a type specified by the Oracle Type + System (OTS). This section describes how an OTS instance can be + represented in OCI. In OCI, an OTS instance can be classified based on + the type, the lifetime and referencability (see the figure below): + + 1) A persistent object is an instance of an object type. A persistent + object resides in a row of a table in the server and can exist longer + than the duration of a session (connection). Persistent objects can be + identified by object references which contain the object identifiers. + A persistent object is obtained by pinning its object reference. + + 2) A transient object is an instance of an object type. A transient + object cannot exist longer than the duration of a session, and it is + used to contain temporary computing results. Transient objects can + also be identified by references which contain transient object + identifiers. + + 3) A value is an instance of an user-defined type (object type or + collection type) or any built-in OTS type. Unlike objects, values of + object types are identified by memory pointers, rather than by + references. + + A value can be standalone or embbeded. A standalone value is usually + obtained by issuing a select statement. OCI also allows the client + program to select a row of object table into a value by issuing a SQL + statement. Thus, a referenceable object (in the database) can be + represented as a value (which cannot be identified by a reference). + A standalone value can also be an out-of-line attribute in an object + (e.g varchar, raw) or an out-of-line element in a collection (e.g. + varchar, raw, object). + + An embedded value is phyiscally included in a containing instance. + An embedded value can be an in-line attribute in an object (e.g. + number, nested object) or an in-line element in a collection. + + All values are considered to be transient by OCI, e.g. OCI does not + support automatic flushing a value to the database, and the client has + to explicitly execute a SQL statement to store a value into the + database. For embedded values, they are flushed when their containing + instance are flushed. + + + OTS instance + | | + v v + object value (type) + | | + v v + persistent transient (lifetime) + + + persistent obj transient obj value + --------------------------------------------------------------- + | | | | object type, | + | type | object type | object type | built-in, | + | | | | collection | + --------------------------------------------------------------- + | maximum | until object | session | session | + | lifetime | is deleted | | | + --------------------------------------------------------------- + | referencable | yes | yes | no | + --------------------------------------------------------------- + | embeddable | no | no | yes | + --------------------------------------------------------------- + + REFERENCEABLE OBJECT, STANDALONE OBJECT, EMBEDDED OBJECT + + In the reminding of this include file, the following term will be used: + 1) The term 'object' can be generally referred to a persistent object, + a transient object, a standalone value of object type, or an embedded + value of object type. + 2) The term 'referenceable object' refers to a persistent object or a + transient object. + 3) The term 'standalone object' refers to a persistent object, a + transient object or a standalone value of object type. + 4) The term 'embedded object' referes to a embbeded value of object + type. + + META ATTRIBUTES + + There is a set of meta-attributes that are defined for standalone + objects. A meta-attribute can be transient or persistent. A + transient meta-attribute is applicable to an instance only when it is + in memory. A persistent meta-attribute can be applicable to an instance + that is in the disk. + + The set of user visible meta-attributes for persistent objects are: + 1) existent (persistent) : Does the object exist? + 2) nullness (persistent) : Null information of the instance + 3) locked (persistent) : Is the object locked? + 4) pinned (transient) : Is the object being accessed by the client? + 5) dirty (transient) : Has the object been modified? + 6) allocation duration (transient) : see below + 7) pin duration (transient) : see below + + The set of user visible meta-attributes for transient objects are: + 1) existent (transient) : Does the object exist? + 2) nullness (transient) : Null information of the instance + 3) pinned (transient) : Is the object being accessed by the client? + 4) dirty (transient) : Has the object been modified? + 4) allocation duration (transient) : see below + 5) pin duration (transient) : see below + + The set of user visible meta-attributes for standalone values of object + type or collections are: + 1) allocation duration (transient) : see below + 2) nullness (transient) : Null information of the instance + (of an object type) + + NULLNESS OF AN INSTANCE + + Each standalone object is associated with a null structure which keeps + the null information about the object. A null indicates the absence of + data. The null structure itself contains null indicators that represent: + 1) atomic nullness : a null value that pertains to the whole object + 2) null status of the individual attribute in the object + + The layout of a null structure in memory resembles that of the object, + except that the null structure has additional indicators to represent + the atomic nullness for each object. + + An non-existent object is different than an object that is atomically + null. A atomically null object is an existing object that has no data. + + MEMORY LAYOUT OF AN OBJECT + + A standalone object in memory is composed of a top level memory chunk, + a null structure and optionally, a number of secondary memory chunks. + For a DEPARTMENT object type, + + OBJECT TYPE department + { + dep_name varchar2(20), + budget number, + manager person, /o person is an object type o/ + employees collection of person + } + + Each instance of DEPARTMENT will has a top level memory chunk which + contains the top level attributes such as dep_name, budget, manager and + employees. The attributes dep_name and employees are themselves pointers + to the additional memory (the secondary memory chunks). The secondary + memory is for the out-of-line attribute (e.g. varray). + + CONSISTENCY MODEL + + Each pin operation behaves like a distinct SQL select. Thus, the object + cache does not guarantee consistency for a graph of objects. In order to + retrieve a consistent graph of objects, the user has to explicitly start + a serializable transaction or a read-only transaction. + + DURATION + In OCI, a duration is used to specify + + 1) the length of memory allocation of an instance + When each instance is allocated, it is associate with an allocation + duration. The memory occupied by the object is freed automatically + at the end of its allocation duration. The allocation duration of an + instance cannot be changed. + + 2) the length of pinning of an object + When each object is pinned, the client has to give a pin duration + which specify the length of time that the object is intended to be + used. It is an user error to specify a pin duration longer than an + allocation duration of the object. An object is completely unpinned + at the end of its pin duration (see OCIObjectUnpin()). + + An OCI program can use the allocation duration and the pin duration to + automatically free the memory of the instances: + 1) Transient objects and values are freed at the end of the allocation + duration. + 2) Persistent objects ARE freed at the end of the allocation duration. + Persistent objects CAN be freed at the end of the pin duration when + the objects are completely unpinned. The persistent objects are said + to be aged out. See OCIObjectUnpin() for more details. + + There are 3 predefined duration: session, transaction, call. The time + spans of these durations are defined based on the programming model + presented by OCI. The call duration is mapped to the transaction + duration in the client-side environment. See oro.h for the macros defined + for these 3 durations. + + A pin duration can be promoted. For example, if an object is pinned with + duration 1, and the object is later pinned with duration 2, the pin + routine will try to find a duration that is longer or equal to the + length of both duration 1 and duration 2. The pin duration of the object + is set to the that duration. The object is automatically unpinned only + after both duration 1 and duration 2 are terminated. + + RELATED DOCUMENTS + "Functional Specification for Oracle Object RDBMS" + "Functional Specification for Programmatic Interfaces" + "Functional Specification for the Oracle Type System (OTS)" + + INSPECTION STATUS + Inspection date: + Inspection status: + Estimated increasing cost defects per page: + Rule sets: + + ACCEPTANCE REVIEW STATUS + Review date: + Review status: + Reviewers: + + PUBLIC FUNCTIONS + OCIObjectNew - OCI new a standalone instance + OCIObjectPin - OCI pin an object by reference + OCIObjectUnpin - OCI unpin a referenceable object + OCIObjectPinCountReset - OCI reset the pin count of a referenceable object + OCIObjectLock - OCI lock a persistent object + OCIObjectLockNoWait - OCI lock a persistent object + OCIObjectMarkUpdate - OCI mark a referenceable object as updated + OCIObjectUnmark - OCI unmark a dirtied referenceable object + OCIObjectUnmarkByRef - OCI unmark a dirtied object by reference + OCIObjectFree - OCI free a standalone instance + OCIObjectMarkDelete - OCI mark a referenceable object as deleted + OCIObjectMarkDeleteByRef - OCI mark a referenceable object as deleted by + giving a reference + OCIObjectFlush - OCI flush a persistent object + OCIObjectRefresh - OCI refresh a persistent object + OCIObjectCopy - OCI CoPy one object to another + OCIObjectGetTypeRef - OCI get the Type Reference of a standalone object + OCIObjectGetObjectRef - OCI get the Object's Reference + OCIObjectGetInd - OCI get Null Structure of an standalone object + OCIObjectExists - OCI get the existence of a referenceable object + OCIObjectGetProperty - get object property + OCIObjectIsLocked - OCI get the lock status of a referenceable object + OCIObjectIsDirty - OCI get the dirty status of a referenceable object + OCIObjectPinTable - OCI get Table object + OCIObjectArrayPin - OCI pin array of objects + OCIObjectGetPrimayKeyTypeRef - OCI get the Ref for the primary key OID's + type + OCIObjectMakeObjectRef - OCI Create a pk or sys generated REF + + OCIObjectGetNewOID - OCI Create a new Object ID + + OCICacheFlush - OCI flsuh the modified persistent objects in the cache + OCICacheRefresh - OCI refresh persistent objects in the cache + OCICacheUnpin - OCI unpin referenceable objects in the cache + OCICacheFree - OCI free all instances in the environment + OCICacheUnmark - OCI unmark all dirty referenceable objects in the cache + + PRIVATE FUNCTIONS + None + + EXAMPLES + + The following types will be used in the examples in this section: + + OBJECT TYPE professor + ( + varchar2 name; + number department; + number num_of_students; + ); + + OBJECT TYPE course + ( + varchar2 name; + number grade; + ); + + OBJECT TYPE student + ( + vstring name; + number department; + ref advisor; /o advisor is a professor o/ + collection courses; + ); + + EXAMPLE 1 + + Here is a set of examples to illustrate the usages of some of the + orio and oric functions. + + OCIenv *env; /o OCI environment handle o/ + OCIError *err; /o OCI error handle o/ + OCISvcCtx *svc; /o OCI service handle o/ + + void *stu_tbl; /o pointer to the student table o/ + OCIType *stu_tdo; /o student type tdo o/ + + OCIRef *stu2_ref; /o object reference to student object o/ + student *stu1; /o pointer to the student object o/ + student *stu2; /o pointer to the student object o/ + professor *pro; /o pointer to the professor object o/ + + /o Initialize the OCI environment handle, error handle and service + handle and login to the database o/ + ... + + /o CREATE A PERSISTENT OBJECT o/ + + /o get the table object of student o/ + if (OCIObjectPinTable(env, err, svc, "ORACLEU", sizeof("ORACLEU"), + "STUDENT_TABLE", sizeof("STUDENT_TABLE"), (OCIRef *)0, + OCI_DURATION_NULL, &stu_tbl) != OCI_SUCCESS) + /o error handling code o/ + + /o get type object of student o/ + if (OCITypeByName(env, err, svc, "ORACLEU", sizeof("ORACLEU"), + "STUDENT", sizeof("STUDENT"), OCI_DURATION_NULL, OCI_TYPEGET_HEADER, + &stu_tdo) != OCI_SUCCESS) + /o error handling code o/ + + /o create a persistent object 'mark' (of type student) o/ + if (OCIObjectNew(env, err, svc, OCI_TYPECODE_ADT, stu_tdo, stu_tbl, + OCI_DURATION_TRANS, (ub1)FALSE, (void **)&stu1) != OCI_SUCCESS) + /o error handling code o/ + + /o RETRIEVE OBJECTS IN PERSISTENT STORES o/ + + /o Use OCI to retrieve a reference to student object 'joe'. + o The retrieved reference is bound to the variable stu2_ref. + o/ + + /o pin/retrieve the student "joe" by reference o/ + if (OCIObjectPin(env, err, &stu2_ref, (OCIComplexObject *)0, OCI_PIN_ANY, + OCI_DURATION_TRANS, OCI_LOCK_X, &stu2) != OCI_SUCCESS) + /o error handling code o/ + + /o pin/retrieve the advisor of student "joe" by reference o/ + if (OCIObjectPin(env, err, &stu2->advisor, (OCIComplexObject *)0, + OCI_PIN_ANY, OCI_DURATION_TRANS, OCI_LOCK_X, &pro) != OCI_SUCCESS) + /o error handling code o/ + + /o MODIFY OBJECTS o/ + + /o initialize the newly created object "mark" o/ + DISCARD OCIStringAssignText(env, err, "mark", sizeof("mark"), + &stu1->name); + department = 522; + DISCARD OCINumberFromInt(err, &department, sizeof(department), + OCI_NUMBER_UNSIGNED, &stu1->department); + + /o assign advisor to student "mark" o/ + DISCARD OCIRefAssign(env, err, &stu2->advisor, &stu1->advisor); + + /o update student "joe". o/ + department = 533; + DISCARD OCINumberFromInt(err, &department, sizeof(department), + OCI_NUMBER_UNSIGNED, &stu2->department); + DISCARD OCIObjectMarkUpdate(env, err, stu2); + + /o UNPIN OBJECTS AFTER FINSIHED PROCESSING THEM o/ + + /o unpin the student object "mark" o/ + if (OCIObjectUnpin(env, err, stu1) != OCI_SUCCESS) + /o error handling code o/ + + /o unpin the student object "joe" o/ + if (OCIObjectUnpin(env, err, stu2) != OCI_SUCCESS) + /o error handling code o/ + + /o unpin the professor object o/ + if (OCIObjectUnpin(env, err, pro) != OCI_SUCCESS) + /o error handling code o/ + + /o unpin the type object o/ + if (OCIObjectUnpin(env, err, stu_tdo) != OCI_SUCCESS) + /o error handling code o/ + + /o unpin the table object o/ + if (OCIObjectUnpin(env, err, stu_tbl) != OCI_SUCCESS) + /o error handling code o/ + + /o FLUSH MODIFIED OBJECTS BACK TO PERSISTENT STORE o/ + + if (OCICacheFlush(env, err, svc, (void *)0, ((OCIRef*)(*)())0, + (OCIRef *)0) != OCI_SUCCESS) + /o error handling code o/ + + /o commit transaction o/ + + END OF EXAMPLE 1 + + NOTES + This file has been subsetted to contain only the routines that will + be in the first release. + + MODIFIED + dmukhin 06/29/05 - ANSI prototypes; miscellaneous cleanup + srseshad 03/12/03 - convert oci public api to ansi + aahluwal 06/03/02 - bug 2360115 + bpalaval 02/09/01 - Change text to oratext. + rkasamse 06/21/00 - add ociobjectgetnewoid + rkasamse 05/24/00 - add OCIObjectSetData + whe 09/01/99 - 976457:check __cplusplus for C++ code + smuralid 10/29/98 - add comments for OCIObjectMakeObjectRef + mkrishna 08/19/98 - change OCIGetPkTypeRef to OCIObjectGetPrimaryKeyTypeR + mkrishna 08/10/98 - add OCIObjectMakeObjectRef & OCIObjectGetPkTypeRef + rkasamse 06/22/98 - add comments for OCIDurationBegin(End) + pmitra 04/01/98 - OCIObjectLockNoWait added + pmitra 11/05/97 - [573769] OCIObjectArrayPin pos parameter cannot be NU + cxcheng 07/29/97 - fix compile for short names + skrishna 07/14/97 - add OCIObjectGetProperty + skrishna 04/30/97 - OCIObjectFlushRefresh: remove duplicate declaration + skrishna 04/24/97 - flag unsupported functions + sthakur 03/20/97 - modify flag argument to OCIObjectFree + skrishna 03/18/97 - fix ifdef for supporting ansi and k&r proto-types + cxcheng 02/19/97 - remove short names support + cxcheng 02/06/97 - take out short name support except with SLSHORTNAME + sthakur 12/20/96 - fix a typepo in OCIOBjectArrayPin + jboonleu 11/07/96 - modify comments + cxcheng 10/28/96 - more beautification changes + jboonleu 10/24/96 - add flag to OCIObjectFree + jboonleu 10/22/96 - change interface of OCICacheFlush + cxcheng 10/18/96 - rename OCIObjectPinArray to OCIObjectArrayPin + cxcheng 10/14/96 - more renaming of types + jboonleu 10/09/96 - add new interfaces + cxcheng 10/09/96 - more lint fixes + cxcheng 10/08/96 - more lint fixes + jboonleu 09/27/96 - fix lint errors + jboonleu 10/07/96 - beautify ori.h after conversion to long names + cxcheng 10/04/96 - replace short names with long names + sthakur 08/20/96 - add COR context to OCIObjectPin + mluong 07/17/96 - add back orioglk, oriogdr, oriogiv, and oriocur. + jboonleu 07/17/96 - rename refresh option to conherency option + jboonleu 07/16/96 - change comment for cache consistency + jwijaya 07/03/96 - add ANSI prototypes + jboonleu 06/12/96 - update comment + jboonleu 05/08/96 - change description of OCIDurationGetParent + jboonleu 05/01/96 - add OROOCOSFN + skrishna 04/08/96 - change ori*() to take OCIEnv* and OCIError* instead + of oroenv* + jboonleu 01/04/96 - interface change + jboonleu 10/24/95 - support of variable ref + jboonleu 02/15/95 - new interface + sthakur 01/05/95 - pass username to origrgc + skotsovo 12/07/94 - update example + jwijaya 11/15/94 - rename ORONSPTAB to ORONSPEXT + jwijaya 10/06/94 - add namespace to oriopnm() + jwijaya 10/02/94 - connection handle -> connection number + jboonleu 08/16/94 - fix lint errors + jboonleu 07/20/94 - change interface of OCICacheFlush + tanguyen 07/18/94 - add oriocpe, change OCIObjectCopy to oriocps + tcheng 07/15/94 - add init param maximum_sga_heap_size + tcheng 07/13/94 - change origini to get param string + jboonleu 07/05/94 - change sccs string from sccid to a comment + jboonleu 07/01/94 - Add examples to ORIO* and ORIC* functions + tanguyen 06/30/94 - Fix the ORI_ORACLE ifdef + skotsovo 06/27/94 - include all public functions in public functions + list at top of header file + tcheng 06/27/94 - modify comments according to new template + tanguyen 06/24/94 - fix comments for OCIObjectCopy + tcheng 06/24/94 - fix comments in origrgc() + tanguyen 06/21/94 - fix comments and format + tcheng 06/20/94 - commenting origini/trm/err/rgc/urg() functions + tanguyen 06/16/94 - fix descriptions of ref operations + tanguyen 06/16/94 - clarifies refs comparison + tanguyen 05/12/94 - adds more interfaces (OCIObjectMarkUpdate) + jwijaya 05/10/94 - fix examples, add origurg, change origcon to origrgc + tanguyen 05/03/94 - remove unnecessary 'type' argument from + 'OCIObjectCopy' + tanguyen 03/08/94 - clarifies comments + jwijaya 02/16/94 - more questions + jwijaya 02/11/94 - more comments + jwijaya 02/10/94 - identify optional arguments + jwijaya 02/07/94 - Creation +*/ + + +#ifndef ORATYPES +#include +#endif +#ifndef ORO_ORACLE +#include +#endif +#ifndef OCI_ORACLE +#include +#endif +#ifndef ORT_ORACLE +#include +#endif + +#ifndef ORI_ORACLE +#define ORI_ORACLE + +/*---------------------------------------------------------------------------*/ +/* SHORT NAMES SUPPORT SECTION */ +/*---------------------------------------------------------------------------*/ + +#ifdef SLSHORTNAME + +/* the following are short names that are only supported on IBM mainframes + with the SLSHORTNAME defined. + With this all subsequent long names will actually be substituted with + the short names here */ + +#define OCIDurationBegin origbgu +#define OCIDurationEnd origedu +#define OCIDurationGetParent origpdr +#define OCICacheFlushRefresh oricfrh +#define OCICacheUnpin oricunp +#define OCICacheFree oricfre +#define OCICacheUnmark oricumk +#define OCICacheGetObjects oricgpr +#define OCICacheRegister oricscb +#define OCIObjectUnpin oriounp +#define OCIObjectPinCountReset orioupz +#define OCIObjectLock oriolck +#define OCIObjectLockNoWait oriolnw +#define OCIObjectMarkUpdate orioupd +#define OCIObjectUnmark orioumk +#define OCIObjectUnmarkByRef orioumr +#define OCIObjectAlwaysLatest oriomkl +#define OCIObjectNotAlwaysLatest oriouml +#define OCIObjectMarkDeleteByRef oriordl +#define OCIObjectMarkDelete oriopdl +#define OCIObjectFlush oriofls +#define OCIObjectFlushRefresh oriofrh +#define OCIObjectCopy oriocpy +#define OCIObjectGetTypeRef oriogtr +#define OCIObjectGetObjectRef oriogor +#define OCIObjectGetInd oriogns +#define OCIObjectExists oriogex +#define OCIObjectGetProperty oriogpr +#define OCIObjectRefresh oriorfs +#define OCIObjectPinTable oriogtb +#define OCIObjectGetPrimaryKeyTypeRef oriogpf +#define OCIObjectMakeObjectRef oriomrf + +#define OCIObjectNew orionew +#define OCIObjectPin oriopin +#define OCIObjectFree oriofre +#define OCIObjectArrayPin orioapn +#define OCIObjectIsDirty oriodrt +#define OCIObjectIsDirtied oriodrd +#define OCIObjectIsLoaded orioldd +#define OCICacheFlush oricfls +#define OCICacheRefresh oricrfs + +#endif /* SLSHORTNAME */ + +/*---------------------------------------------------------------------------*/ +/* PUBLIC TYPES AND CONSTANTS */ +/*---------------------------------------------------------------------------*/ + +/* Also see oro.h. */ + +/*---------------------------------------------------------------------------*/ +/* PUBLIC FUNCTIONS */ +/*---------------------------------------------------------------------------*/ +/*---------------------------------------------------------------------------*/ +/* OBJECT/INSTANCE OPERATIONS */ +/*---------------------------------------------------------------------------*/ + +/*--------------------------- OCIObjectNew ----------------------------------*/ +sword OCIObjectNew( OCIEnv *env, OCIError *err, const OCISvcCtx *svc, + OCITypeCode typecode, OCIType *tdo, void *table, + OCIDuration duration, boolean value, + void **instance ); +/* + NAME: OCIObjectNew - OCI new (create) a standalone instance + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + svc (IN) - OCI service handle. + typecode (IN) - the typecode of the type of the instance. + tdo (IN, optional) - pointer to the type descriptor object. The + TDO describes the type of the instance that is to be + created. Refer to OCITypeByName() for obtaining a TDO. + The TDO is required for creating a named type (e.g. an + object or a collection). + table (IN, optional) - pointer to a table object which specifies a + table in the server. This parameter can be set to NULL + if no table is given. See the description below to find + out how the table object and the TDO are used together + to determine the kind of instances (persistent, + transient, value) to be created. Also see + OCIObjectPinTable() for retrieving a table object. + duration (IN) - this is an overloaded parameter. The use of this + parameter is based on the kind of the instance that is + to be created. + a) persistent object. This parameter specifies the + pin duration. + b) transient object. This parameter specififes the + allocation duration and pin duration. + c) value. This parameter specifies the allocation + duration. + value (IN) - specifies whether the created object is a value. + If TRUE, then a value is created. Otherwise, a + referenceable object is created. If the instance is + not an object, then this parameter is ignored. + instance (OUT) - address of the newly created instance + + REQUIRES: + - a valid OCI environment handle must be given. + DESCRIPTION: + This function creates a new instance of the type specified by the + typecode or the TDO. Based on the parameters 'typecode' (or 'tdo'), + 'value' and 'table', different kinds of instances can be created: + + The parameter 'table' is not NULL? + + yes no + ---------------------------------------------------------------- + | object type (value=TRUE) | value | value | + ---------------------------------------------------------------- + | object type (value=FALSE) | persistent obj | transient obj | + type ---------------------------------------------------------------- + | built-in type | value | value | + ---------------------------------------------------------------- + | collection type | value | value | + ---------------------------------------------------------------- + + This function allocates the top level memory chunk of an OTS instance. + The attributes in the top level memory are initialized (e.g. an + attribute of varchar2 is initialized to a vstring of 0 length). + + If the instance is an object, the object is marked existed but is + atomically null. + + FOR PERSISTENT OBJECTS: + The object is marked dirty and existed. The allocation duration for + the object is session. The object is pinned and the pin duration is + specified by the given parameter 'duration'. + + FOR TRANSIENT OBJECTS: + The object is pinned. The allocation duration and the pin duration are + specified by the given parameter 'duration'. + + FOR VALUES: + The allocation duration is specified by the given parameter 'duration'. + + RETURNS: + if environment handle or error handle is null, return + OCI_INVALID_HANDLE. + if operation suceeds, return OCI_SUCCESS. + if operation fails, return OCI_ERROR. + */ + +/*--------------------------- OCIObjectPin ----------------------------------*/ +sword OCIObjectPin( OCIEnv *env, OCIError *err, OCIRef *object_ref, + OCIComplexObject *corhdl, OCIPinOpt pin_option, + OCIDuration pin_duration, + OCILockOpt lock_option, void **object ); +/* + NAME: OCIObjectPin - OCI pin a referenceable object + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns + OCI_ERROR. The error recorded in 'err' can be + retrieved by calling OCIErrorGet(). + object_ref (IN) - the reference to the object. + corhdl (IN) - handle for complex object retrieval. + pin_option (IN) - See description below. + pin_duration (IN) - The duration of which the object is being accesed + by a client. The object is implicitly unpinned at + the end of the pin duration. + If OCI_DURATION_NULL is passed, there is no pin + promotion if the object is already loaded into + the cache. If the object is not yet loaded, then + the pin duration is set to OCI_DURATION_DEFAULT. + lock_option (IN) - lock option (e.g., exclusive). If a lock option + is specified, the object is locked in the server. + See 'oro.h' for description about lock option. + object (OUT) - the pointer to the pinned object. + + REQUIRES: + - a valid OCI environment handle must be given. + DESCRIPTION: + + This function pins a referenceable object instance given the object + reference. The process of pinning serves three purposes: + + 1) locate an object given its reference. This is done by the object + cache which keeps track of the objects in the object heap. + + 2) notify the object cache that an object is being in use. An object + can be pinned many times. A pinned object will remain in memory + until it is completely unpinned (see OCIObjectUnpin()). + + 3) notify the object cache that a persistent object is being in use + such that the persistent object cannot be aged out. Since a + persistent object can be loaded from the server whenever is needed, + the memory utilization can be increased if a completely unpinned + persistent object can be freed (aged out), even before the + allocation duration is expired. + + Also see OCIObjectUnpin() for more information about unpinning. + + FOR PERSISTENT OBJECTS: + + When pinning a persistent object, if it is not in the cache, the object + will be fetched from the persistent store. The allocation duration of + the object is session. If the object is already in the cache, it is + returned to the client. The object will be locked in the server if a + lock option is specified. + + This function will return an error for a non-existent object. + + A pin option is used to specify the copy of the object that is to be + retrieved: + + 1) If option is OCI_PIN_ANY (pin any), if the object is already + in the environment heap, return this object. Otherwise, the object + is retrieved from the database. This option is useful when the + client knows that he has the exclusive access to the data in a + session. + + 2) If option is OCI_PIN_LATEST (pin latest), if the object is + not cached, it is retrieved from the database. If the object is + cached, it is refreshed with the latest version. See + OCIObjectRefresh() for more information about refreshing. + + 3) If option is OCI_PIN_RECENT (pin recent), if the object is loaded + into the cache in the current transaction, the object is returned. + If the object is not loaded in the current transaction, the object + is refreshed from the server. + + FOR TRANSIENT OBJECTS: + + This function will return an error if the transient object has already + been freed. This function does not return an error if an exclusive + lock is specified in the lock option. + + RETURNS: + if environment handle or error handle is null, return + OCI_INVALID_HANDLE. + if operation suceeds, return OCI_SUCCESS. + if operation fails, return OCI_ERROR. + */ + +/*------------------------------ OCIObjectUnpin -----------------------------*/ +sword OCIObjectUnpin( OCIEnv *env, OCIError *err, void *object ); +/* + NAME: OCIObjectUnpin - OCI unpin a referenceable object + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by + calling OCIErrorGet(). + object (IN) - pointer to an object + REQUIRES: + - a valid OCI environment handle must be given. + - The specified object must be pinned. + DESCRIPTION: + This function unpins an object. An object is completely unpinned when + 1) the object was unpinned N times after it has been pinned N times + (by calling OCIObjectPin()). + 2) it is the end of the pin duration + 3) the function OCIObjectPinCountReset() is called + + There is a pin count associated with each object which is incremented + whenever an object is pinned. When the pin count of the object is zero, + the object is said to be completely unpinned. An unpinned object can + be freed without error. + + FOR PERSISTENT OBJECTS: + When a persistent object is completely unpinned, it becomes a candidate + for aging. The memory of an object is freed when it is aged out. Aging + is used to maximize the utilization of memory. An dirty object cannot + be aged out unless it is flushed. + + FOR TRANSIENT OBJECTS: + The pin count of the object is decremented. A transient can be freed + only at the end of its allocation duration or when it is explicitly + deleted by calling OCIObjectFree(). + + FOR VALUE: + This function will return an error for value. + + RETURNS: + if environment handle or error handle is null, return + OCI_INVALID_HANDLE. + if operation suceeds, return OCI_SUCCESS. + if operation fails, return OCI_ERROR. + */ + +/*---------------------------- OCIObjectPinCountReset -----------------------*/ +sword OCIObjectPinCountReset( OCIEnv *env, OCIError *err, void *object ); +/* + NAME: OCIObjectPinCountReset - OCI resets the pin count of a referenceable + object + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by + calling OCIErrorGet(). + object (IN) - pointer to an object + REQUIRES: + - a valid OCI environment handle must be given. + - The specified object must be pinned. + DESCRIPTION: + This function completely unpins an object. When an object is + completely unpinned, it can be freed without error. + + FOR PERSISTENT OBJECTS: + When a persistent object is completely unpinned, it becomes a candidate + for aging. The memory of an object is freed when it is aged out. Aging + is used to maximize the utilization of memory. An dirty object cannot + be aged out unless it is flushed. + + FOR TRANSIENT OBJECTS: + The pin count of the object is decremented. A transient can be freed + only at the end of its allocation duration or when it is explicitly + freed by calling OCIObjectFree(). + + FOR VALUE: + This function will return an error for value. + + RETURNS: + if environment handle or error handle is null, return + OCI_INVALID_HANDLE. + if operation suceeds, return OCI_SUCCESS. + if operation fails, return OCI_ERROR. + */ + +/*--------------------------- OCIObjectLock ---------------------------------*/ +sword OCIObjectLock( OCIEnv *env, OCIError *err, void *object ); +/* + NAME: OCIObjectLock - OCI lock a persistent object + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by + calling OCIErrorGet(). + object (IN) - pointer to the persistent object + REQUIRES: + - a valid OCI environment handle must be given. + - The specified object must be pinned. + DESCRIPTION: + This function locks a persistent object at the server. Unlike + OCIObjectLockNoWait() this function waits if another user currently + holds a lock on the desired object. This function + returns an error if: + 1) the object is non-existent. + + This function will return an error for transient objects and values. + The lock of an object is released at the end of a transaction. + + RETURNS: + if environment handle or error handle is null, return + OCI_INVALID_HANDLE. + if operation suceeds, return OCI_SUCCESS. + if operation fails, return OCI_ERROR. +*/ + +/*------------------------ OCIObjectLockNoWait ------------------------------*/ +sword OCIObjectLockNoWait( OCIEnv *env, OCIError *err, void *object ); +/* + NAME: OCIObjectLockNoWait - OCI lock a persistent object, do not wait for + the lock, return error if lock not available + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by + calling OCIErrorGet(). + object (IN) - pointer to the persistent object + REQUIRES: + - a valid OCI environment handle must be given. + - The specified object must be pinned. + DESCRIPTION: + This function locks a persistent object at the server. Unlike + OCIObjectLock() this function will not wait if another user holds + the lock on the desired object. This function returns an error if: + 1) the object is non-existent. + 2) the object is currently locked by another user in which + case this function returns with an error. + + This function will return an error for transient objects and values. + The lock of an object is released at the end of a transaction. + + RETURNS: + if environment handle or error handle is null, return + OCI_INVALID_HANDLE. + if operation suceeds, return OCI_SUCCESS. + if operation fails, return OCI_ERROR. +*/ + +/*--------------------------- OCIObjectMarkUpdate ---------------------------*/ +sword OCIObjectMarkUpdate( OCIEnv *env, OCIError *err, void *object ); +/* + NAME: OCIObjectMarkUpdate - OCI marks an object as updated + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by + calling OCIErrorGet(). + object (IN) - pointer to the persistent object + REQUIRES: + - a valid OCI environment handle must be given. + - The specified object must be pinned. + DESCRIPTION: + FOR PERSISTENT OBJECTS: + This function marks the specified persistent object as updated. The + persistent objects will be written to the server when the object cache + is flushed. The object is not locked or flushed by this function. It + is an error to update a deleted object. + + After an object is marked updated and flushed, this function must be + called again to mark the object as updated if it has been dirtied + after it is being flushed. + + FOR TRANSIENT OBJECTS: + This function marks the specified transient object as updated. The + transient objects will NOT be written to the server. It is an error + to update a deleted object. + + FOR VALUES: + It is an no-op for values. + + RETURNS: + if environment handle or error handle is null, return + OCI_INVALID_HANDLE. + if operation suceeds, return OCI_SUCCESS. + if operation fails, return OCI_ERROR. + */ + +/*----------------------------- OCIObjectUnmark -----------------------------*/ +sword OCIObjectUnmark( OCIEnv *env, OCIError *err, void *object ); +/* + NAME: OCIObjectUnmark - OCI unmarks an object + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by + calling OCIErrorGet(). + object (IN) - pointer to the persistent object + REQUIRES: + - a valid OCI environment handle must be given. + - The specified object must be pinned. + DESCRIPTION: + FOR PERSISTENT OBJECTS AND TRANSIENT OBJECTS: + This function unmarks the specified persistent object as dirty. Changes + that are made to the object will not be written to the server. If the + object is marked locked, it remains marked locked. The changes that + have already made to the object will not be undone implicitly. + + FOR VALUES: + It is an no-op for values. + + RETURNS: + if environment handle or error handle is null, return + OCI_INVALID_HANDLE. + if operation suceeds, return OCI_SUCCESS. + if operation fails, return OCI_ERROR. + */ + +/*----------------------------- OCIObjectUnmarkByRef ------------------------*/ +sword OCIObjectUnmarkByRef( OCIEnv *env, OCIError *err, OCIRef *ref ); +/* + NAME: OCIObjectUnmarkByRef - OCI unmarks an object by Ref + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by + calling OCIErrorGet(). + ref (IN) - reference of the object + REQUIRES: + - a valid OCI environment handle must be given. + - The specified object must be pinned. + DESCRIPTION: + FOR PERSISTENT OBJECTS AND TRANSIENT OBJECTS: + This function unmarks the specified persistent object as dirty. Changes + that are made to the object will not be written to the server. If the + object is marked locked, it remains marked locked. The changes that + have already made to the object will not be undone implicitly. + + FOR VALUES: + It is an no-op for values. + + RETURNS: + if environment handle or error handle is null, return + OCI_INVALID_HANDLE. + if operation suceeds, return OCI_SUCCESS. + if operation fails, return OCI_ERROR. + */ + +/*--------------------------- OCIObjectFree ---------------------------------*/ +sword OCIObjectFree( OCIEnv *env, OCIError *err, void *instance, + ub2 flags ); +/* + NAME: OCIObjectFree - OCI free (and unpin) an standalone instance + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns + OCI_ERROR. The error recorded in 'err' can be + retrieved by calling OCIErrorGet(). + instance (IN) - pointer to a standalone instance. + flags (IN) - If OCI_OBJECT_FREE_FORCE is set, free the object + even if it is pinned or dirty. + If OCI_OBJECT_FREE_NONULL is set, the null + structure will not be freed. + REQUIRES: + - a valid OCI environment handle must be given. + - The instance to be freed must be standalone. + - If the instance is a referenceable object, the object must be pinned. + DESCRIPTION: + This function deallocates all the memory allocated for an OTS instance, + including the null structure. + + FOR PERSISTENT OBJECTS: + This function will return an error if the client is attempting to free + a dirty persistent object that has not been flushed. The client should + either flush the persistent object or set the parameter 'flag' to + OCI_OBJECT_FREE_FORCE. + + This function will call OCIObjectUnpin() once to check if the object + can be completely unpin. If it succeeds, the rest of the function will + proceed to free the object. If it fails, then an error is returned + unless the parameter 'flag' is set to OCI_OBJECT_FREE_FORCE. + + Freeing a persistent object in memory will not change the persistent + state of that object at the server. For example, the object will + remain locked after the object is freed. + + FOR TRANSIENT OBJECTS: + + This function will call OCIObjectUnpin() once to check if the object + can be completely unpin. If it succeeds, the rest of the function will + proceed to free the object. If it fails, then an error is returned + unless the parameter 'flag' is set to OCI_OBJECT_FREE_FORCE. + + FOR VALUES: + The memory of the object is freed immediately. + + RETURNS: + if environment handle or error handle is null, return + OCI_INVALID_HANDLE. + if operation suceeds, return OCI_SUCCESS. + if operation fails, return OCI_ERROR. +*/ + +/*----------------------- OCIObjectMarkDeleteByRef --------------------------*/ +sword OCIObjectMarkDeleteByRef( OCIEnv *env, OCIError *err, + OCIRef *object_ref); +/* + NAME: OCIObjectMarkDeleteByRef - OCI "delete" (and unpin) an object given + a reference + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns + OCI_ERROR. The error recorded in 'err' can be + retrieved by calling OCIErrorGet(). + object_ref (IN) - ref of the object to be deleted + + REQUIRES: + - a valid OCI environment handle must be given. + DESCRIPTION: + This function marks the object designated by 'object_ref' as deleted. + + FOR PERSISTENT OBJECTS: + If the object is not loaded, then a temporary object is created and is + marked deleted. Otherwise, the object is marked deleted. + + The object is deleted in the server when the object is flushed. + + FOR TRANSIENT OBJECTS: + The object is marked deleted. The object is not freed until it is + unpinned. + + RETURNS: + if environment handle or error handle is null, return + OCI_INVALID_HANDLE. + if operation suceeds, return OCI_SUCCESS. + if operation fails, return OCI_ERROR. + */ + +/*--------------------------- OCIObjectMarkDelete ---------------------------*/ +sword OCIObjectMarkDelete( OCIEnv *env, OCIError *err, void *instance ); +/* + NAME: OCIObjectMarkDelete - OCI "delete" an instance given a Pointer + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns + OCI_ERROR. The error recorded in 'err' can be + retrieved by calling OCIErrorGet(). + instance (IN) - pointer to the instance + REQUIRES: + - a valid OCI environment handle must be given. + - The instance must be standalone. + - If the instance is a referenceable object, then it must be pinned. + DESCRIPTION: + + FOR PERSISTENT OBJECTS: + The object is marked deleted. The memory of the object is not freed. + The object is deleted in the server when the object is flushed. + + FOR TRANSIENT OBJECTS: + The object is marked deleted. The memory of the object is not freed. + + FOR VALUES: + This function frees a value immediately. + + RETURNS: + if environment handle or error handle is null, return + OCI_INVALID_HANDLE. + if operation suceeds, return OCI_SUCCESS. + if operation fails, return OCI_ERROR. + */ + +/*---------------------------- OCIObjectFlush -------------------------------*/ +sword OCIObjectFlush( OCIEnv *env, OCIError *err, void *object ); +/* + NAME: OCIObjectFlush - OCI flush a persistent object + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns + OCI_ERROR. The error recorded in 'err' can be + retrieved by calling OCIErrorGet(). + object (IN) - pointer to the persistent object + REQUIRES: + - a valid OCI environment handle must be given. + - The specified object must be pinned. + DESCRIPTION: + This function flushes a modified persistent object to the server. + An exclusive lock is obtained implicitly for the object when flushed. + + When the object is written to the server, triggers may be fired. + Objects can be modified by the triggers at the server. To keep the + objects in the object cache being coherent with the database, the + clients can free or refresh the objects in the cache. + + This function will return an error for transient objects and values. + + RETURNS: + if environment handle or error handle is null, return + OCI_INVALID_HANDLE. + if operation suceeds, return OCI_SUCCESS. + if operation fails, return OCI_ERROR. + */ + +/*------------------------ OCIObjectRefresh ---------------------------------*/ +sword OCIObjectRefresh( OCIEnv *env, OCIError *err, void *object ); +/* + NAME: OCIObjectRefresh - OCI refresh a persistent object + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns + OCI_ERROR. The error recorded in 'err' can be + retrieved by calling OCIErrorGet(). + object (IN) - pointer to the persistent object + REQUIRES: + - a valid OCI environment handle must be given. + - The specified object must be pinned. + DESCRIPTION: + This function refreshes an unmarked object with data retrieved from the + latest snapshot in the server. An object should be refreshed when the + objects in the cache are inconsistent with the objects at + the server: + 1) When an object is flushed to the server, triggers can be fired to + modify more objects in the server. The same objects (modified by + the triggers) in the object cache become obsolete. + 2) When the user issues a SQL or executes a PL/SQL procedure to modify + any object in the server, the same object in the cache becomes + obsolete. + + The object that is refreshed will be 'replaced-in-place'. When an + object is 'replaced-in-place', the top level memory of the object will + be reused so that new data can be loaded into the same memory address. + The top level memory of the null structre is also reused. Unlike the + top level memory chunk, the secondary memory chunks may be resized and + reallocated. The client should be careful when holding onto a pointer + to the secondary memory chunk (e.g. assigning the address of a + secondary memory to a local variable), since this pointer can become + invalid after the object is refreshed. + + The object state will be modified as followed after being refreshed: + - existent : set to appropriate value + - pinned : unchanged + - allocation duration : unchanged + - pin duration : unchanged + + This function is an no-op for transient objects or values. + + RETURNS: + if environment handle or error handle is null, return + OCI_INVALID_HANDLE. + if operation suceeds, return OCI_SUCCESS. + if operation fails, return OCI_ERROR. + */ + +/*---------------------------- OCIObjectCopy --------------------------------*/ +sword OCIObjectCopy( OCIEnv *env, OCIError *err, const OCISvcCtx *svc, + void *source, void *null_source, + void *target, void *null_target, OCIType *tdo, + OCIDuration duration, ub1 option ); +/* + NAME: OCIObjectCopy - OCI copy one instance to another + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns + OCI_ERROR. The error recorded in 'err' can be + retrieved by calling OCIErrorGet(). + svc (IN) - OCI service context handle + source (IN) - pointer to the source instance + null_source (IN) - pointer to the null structure of the source + target (IN) - pointer to the target instance + null_target (IN) - pointer to the null structure of the target + tdo (IN) - the TDO for both source and target + duration (IN) - allocation duration of the target memory + option (IN) - specify the copy option: + OROOCOSFN - Set Reference to Null. All references + in the source will not be copied to the target. The + references in the target are set to null. + REQUIRES: + - a valid OCI environment handle must be given. + - If source or target is referenceable, it must be pinned. + - The target or the containing instance of the target must be already + be instantiated (e.g. created by OCIObjectNew()). + - The source and target instances must be of the same type. If the + source and target are located in a different databases, then the + same type must exist in both databases. + DESCRIPTION: + This function copies the contents of the 'source' instance to the + 'target' instance. This function performs a deep-copy such that the + data that is copied/duplicated include: + a) all the top level attributes (see the exceptions below) + b) all the secondary memory (of the source) that is reachable from the + top level attributes. + c) the null structure of the instance + + Memory is allocated with the specified allocation duration. + + Certain data items are not copied: + a) If the option OCI_OBJECTCOPY_NOREF is specified, then all references + in the source are not copied. Instead, the references in the target + are set to null. + b) If the attribute is a LOB, then it is set to null. + + RETURNS: + if environment handle or error handle is null, return + OCI_INVALID_HANDLE. + if operation suceeds, return OCI_SUCCESS. + if operation fails, return OCI_ERROR. + */ + +/*---------------------------- OCIObjectGetTypeRef --------------------------*/ +sword OCIObjectGetTypeRef( OCIEnv *env, OCIError *err, void *instance, + OCIRef *type_ref ); +/* + NAME: OCIObjectGetTypeRef - get the type reference of a standalone object + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns + OCI_ERROR. The error recorded in 'err' can be + retrieved by calling OCIErrorGet(). + instance (IN) - pointer to an standalone instance + type_ref (OUT) - reference to the type of the object. The reference + must already be allocated. + REQUIRES: + - a valid OCI environment handle must be given. + - The instance must be standalone. + - If the object is referenceable, the specified object must be pinned. + - The reference must already be allocated. + DESCRIPTION: + This function returns a reference to the TDO of a standalone instance. + RETURNS: + if environment handle or error handle is null, return + OCI_INVALID_HANDLE. + if operation suceeds, return OCI_SUCCESS. + if operation fails, return OCI_ERROR. + */ + +/*--------------------------- OCIObjectGetObjectRef -------------------------*/ +sword OCIObjectGetObjectRef( OCIEnv *env, OCIError *err, void *object, + OCIRef *object_ref ); +/* + NAME: OCIObjectGetObjectRef - OCI get the object reference of an + referenceable object + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns + OCI_ERROR. The error recorded in 'err' can be + retrieved by calling OCIErrorGet(). + object (IN) - pointer to a persistent object + object_ref (OUT) - reference of the given object. The reference must + already be allocated. + REQUIRES: + - a valid OCI environment handle must be given. + - The specified object must be pinned. + - The reference must already be allocated. + DESCRIPTION: + This function returns a reference to the given object. It returns an + error for values. + RETURNS: + if environment handle or error handle is null, return + OCI_INVALID_HANDLE. + if operation suceeds, return OCI_SUCCESS. + if operation fails, return OCI_ERROR. + */ + +/*--------------------------- OCIObjectMakeObjectRef -----------------------*/ +sword OCIObjectMakeObjectRef( OCIEnv *env, OCIError *err, + const OCISvcCtx *svc, void * table, + void **values, ub4 array_len, + OCIRef *object_ref ); +/* + NAME: OCIObjectMakeObjectRef - OCI Create an object reference to a + referenceable object. + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns + OCI_ERROR. The error recorded in 'err' can be + retrieved by calling OCIErrorGet(). + svc (IN) - the service context + table (IN) - A pointer to the table object (must be pinned) + attrlist (IN) - A list of values (OCI type values) from which + the ref is to be created. + attrcnt (IN) - The length of the attrlist array. + object_ref (OUT) - reference of the given object. The reference must + already be allocated. + REQUIRES: + - a valid OCI environment handle must be given. + - The specified table object must be pinned. + - The reference must already be allocated. + DESCRIPTION: + This function creates a reference given the values that make up the + reference and also a pointer to the table object. + Based on the table's OID property, whether it is a pk based OID or + a system generated OID, the function creates a sys-generated REF or + a pk based REF. + In case of system generated REFs pass in a OCIRaw which is 16 bytes + long contatining the sys generated OID. + In case of PK refs pass in the OCI equivalent for numbers, chars etc.. + RETURNS: + if environment handle or error handle is null, return + OCI_INVALID_HANDLE. + if operation suceeds, return OCI_SUCCESS. + if operation fails, return OCI_ERROR. + */ + +/*--------------------------- OCIObjectGetPrimaryKeyTypeRef --------------- */ +sword OCIObjectGetPrimaryKeyTypeRef( OCIEnv *env, OCIError *err, + const OCISvcCtx *svc, void *table, + OCIRef *type_ref ); +/* + NAME: OCIObjectGetPrimaryKeyTypeRef - OCI get the REF to the pk OID type + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns + OCI_ERROR. The error recorded in 'err' can be + retrieved by calling OCIErrorGet(). + svc (IN) - the service context + table (IN) - pointer to the table object + type_ref (OUT) - reference of the pk type. The reference must + already be allocated. + REQUIRES: + - a valid OCI environment handle must be given. + - The specified table object must be pinned. + - The reference must already be allocated. + DESCRIPTION: + This function returns a reference to the pk type. It returns an + error for values. If the table is not a Pk oid table/view, then + it returns error. + RETURNS: + if environment handle or error handle is null, return + OCI_INVALID_HANDLE. + if operation suceeds, return OCI_SUCCESS. + if operation fails, return OCI_ERROR. + */ + +/*-------------------------- OCIObjectGetInd --------------------------------*/ +sword OCIObjectGetInd( OCIEnv *env, OCIError *err, void *instance, + void **null_struct ); +/* + NAME: OCIObjectGetInd - OCI get the null structure of a standalone object + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns + OCI_ERROR. The error recorded in 'err' can be + retrieved by calling OCIErrorGet(). + instance (IN) - pointer to the instance + null_struct (OUT) - null structure + REQUIRES: + - a valid OCI environment handle must be given. + - The object must be standalone. + - If the object is referenceable, the specified object must be pinned. + DESCRIPTION: + This function returns the null structure of an instance. This function + will allocate the top level memory of the null structure if it is not + already allocated. If an null structure cannot be allocated for the + instance, then an error is returned. This function only works for + ADT or row type instance. + RETURNS: + if environment handle or error handle is null, return + OCI_INVALID_HANDLE. + if operation suceeds, return OCI_SUCCESS. + if operation fails, return OCI_ERROR. + */ + +/*------------------------- OCIObjectExists --------------------------------*/ +sword OCIObjectExists(OCIEnv *env, OCIError *err, void *ins, boolean *exist); +/* + NAME: OCIObjectExist - OCI checks if the object exists + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns + OCI_ERROR. The error recorded in 'err' can be + retrieved by calling OCIErrorGet(). + ins (IN) - pointer to an instance + exist (OUT) - return TRUE if the object exists + REQUIRES: + - a valid OCI environment handle must be given. + - The object must be standalone. + - if object is a referenceable, it must be pinned. + DESCRIPTION: + This function returns the existence of an instance. If the instance + is a value, this function always returns TRUE. + RETURNS: + if environment handle or error handle is null, return + OCI_INVALID_HANDLE. + if operation suceeds, return OCI_SUCCESS. + if operation fails, return OCI_ERROR. + */ + +/*------------------------- OCIObjectGetProperty ---------------------------*/ +sword OCIObjectGetProperty(OCIEnv *envh, OCIError *errh, const void *obj, + OCIObjectPropId propertyId, + void *property, ub4 *size ); +/* + NAME: OCIObjectGetProperty - OCIObject Get Property of given object + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns + OCI_ERROR. The error recorded in 'err' can be + retrieved by calling OCIErrorGet(). + obj (IN) - object whose property is returned + propertyId (IN) - id which identifies the desired property + property (OUT) - buffer into which the desired property is + copied + size (IN/OUT) - on input specifies the size of the property buffer + passed by caller, on output will contain the + size in bytes of the property returned. + This parameter is required for string type + properties only (e.g OCI_OBJECTPROP_SCHEMA, + OCI_OBJECTPROP_TABLE). For non-string + properties this parameter is ignored since + the size is fixed. + DESCRIPTION: + This function returns the specified property of the object. + The desired property is identified by 'propertyId'. The property + value is copied into 'property' and for string typed properties + the string size is returned via 'size'. + + Objects are classified as persistent, transient and value + depending upon the lifetime and referenceability of the object. + Some of the properties are applicable only to persistent + objects and some others only apply to persistent and + transient objects. An error is returned if the user tries to + get a property which in not applicable to the given object. + To avoid such an error, the user should first check whether + the object is persistent or transient or value + (OCI_OBJECTPROP_LIFETIME property) and then appropriately + query for other properties. + + The different property ids and the corresponding type of + 'property' argument is given below. + + OCI_OBJECTPROP_LIFETIME + This identifies whether the given object is a persistent + object (OCI_OBJECT_PERSISTENT) or a + transient object (OCI_OBJECT_TRANSIENT) or a + value instance (OCI_OBJECT_VALUE). + 'property' argument must be a pointer to a variable of + type OCIObjectLifetime. + + OCI_OBJECTPROP_SCHEMA + This returns the schema name of the table in which the + object exists. An error is returned if the given object + points to a transient instance or a value. If the input + buffer is not big enough to hold the schema name an error + is returned, the error message will communicate the + required size. Upon success, the size of the returned + schema name in bytes is returned via 'size'. + 'property' argument must be an array of type text and 'size' + should be set to size of array in bytes by the caller. + + OCI_OBJECTPROP_TABLE + This returns the table name in which the object exists. An + error is returned if the given object points to a + transient instance or a value. If the input buffer is not + big enough to hold the table name an error is returned, + the error message will communicate the required size. Upon + success, the size of the returned table name in bytes is + returned via 'size'. 'property' argument must be an array + of type text and 'size' should be set to size of array in + bytes by the caller. + + OCI_OBJECTPROP_PIN_DURATION + This returns the pin duration of the object. + An error is returned if the given object points to a value + instance. Valid pin durations are: OCI_DURATION_SESSION and + OCI_DURATION_TRANS. + 'property' argument must be a pointer to a variable of type + OCIDuration. + + OCI_OBJECTPROP_ALLOC_DURATION + This returns the allocation duration of the object. + Valid allocation durations are: OCI_DURATION_SESSION and + OCI_DURATION_TRANS. + 'property' argument must be a pointer to a variable of type + OCIDuration. + + OCI_OBJECTPROP_LOCK + This returns the lock status of the + object. The possible lock status is enumerated by OCILockOpt. + An error is returned if the given object points to a transient + or value instance. + 'property' argument must be a pointer to a variable of + type OCILockOpt. + Note, the lock status of an object can also be retrieved by + calling OCIObjectIsLocked(). + + OCI_OBJECTPROP_MARKSTATUS + This returns the status flag which indicates whether the + object is a new object, updated object and/or deleted object. + The following macros can be used to test the mark status + flag: + + OCI_OBJECT_IS_UPDATED(flag) + OCI_OBJECT_IS_DELETED(flag) + OCI_OBJECT_IS_NEW(flag) + OCI_OBJECT_IS_DIRTY(flag) + + An object is dirty if it is a new object or marked deleted or + marked updated. + An error is returned if the given object points to a transient + or value instance. 'property' argument must be of type + OCIObjectMarkStatus. + + OCI_OBJECTPROP_VIEW + This identifies whether the specified object is a view object + or not. If property value returned is TRUE, it indicates the + object is a view otherwise it is not. + 'property' argument must be of type boolean. + + RETURNS: + if environment handle or error handle is null, return + OCI_INVALID_HANDLE. + if operation suceeds, return OCI_SUCCESS. + if operation fails, return OCI_ERROR. Possible errors are TBD + */ + +/*---------------------------- OCIObjectIsLocked --------------------------*/ +sword OCIObjectIsLocked( OCIEnv *env, OCIError *err, void *ins, + boolean *lock); +/* + NAME: OCIObjectIsLocked - OCI get the lock status of a standalone object + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns + OCI_ERROR. The error recorded in 'err' can be + retrieved by calling OCIErrorGet(). + ins (IN) - pointer to an instance + lock (OUT) - return value for the lock status. + REQUIRES: + - a valid OCI environment handle must be given. + - The instance must be standalone. + - If the object is referenceable, the specified object must be pinned. + DESCRIPTION: + This function returns the lock status of an instance. If the instance + is a value, this function always returns FALSE. + RETURNS: + if environment handle or error handle is null, return + OCI_INVALID_HANDLE. + if operation suceeds, return OCI_SUCCESS. + if operation fails, return OCI_ERROR. + */ + +/*------------------------- OCIObjectIsDirty ------------------------------*/ +sword OCIObjectIsDirty( OCIEnv *env, OCIError *err, void *ins, + boolean *dirty); +/* + NAME: OCIObjectIsDirty - OCI get the dirty status of a standalone object + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns + OCI_ERROR. The error recorded in 'err' can be + retrieved by calling OCIErrorGet(). + ins (IN) - pointer to an instance + dirty (OUT) - return value for the dirty status. + REQUIRES: + - a valid OCI environment handle must be given. + - The instance must be standalone. + - if instance is an object, the instance must be pinned. + DESCRIPTION: + This function returns the dirty status of an instance. If the instance + is a value, this function always returns FALSE. + RETURNS: + if environment handle or error handle is null, return + OCI_INVALID_HANDLE. + if operation suceeds, return OCI_SUCCESS. + if operation fails, return OCI_ERROR. + */ + +/*--------------------------- OCIObjectPinTable -----------------------------*/ +sword OCIObjectPinTable( OCIEnv *env, OCIError *err, const OCISvcCtx *svc, + const oratext *schema_name, + ub4 s_n_length, const oratext *object_name, ub4 o_n_length, + const OCIRef *scope_obj_ref, OCIDuration pin_duration, + void ** object ); +/* + NAME: OCIObjectPinTable - OCI get table object + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns + OCI_ERROR. The error recorded in 'err' can be + retrieved by calling OCIErrorGet(). + svc (IN) - OCI service context handle + schema_name (IN, optional) - schema name of the table + s_n_length (IN, optional) - length of the schema name + object_name (IN) - name of the table + o_n_length (IN) - length of the table name + scope_obj_ref (IN, optional) - reference of the scoping object + pin_duration (IN) - pin duration. See description in OCIObjectPin(). + object (OUT) - the pinned table object + REQUIRES: + - a valid OCI environment handle must be given. + DESCRIPTION: + This function pin a table object with the specified pin duration. + The client can unpin the object by calling OCIObjectUnpin(). See + OCIObjectPin() and OCIObjectUnpin() for more information about pinning + and unpinning. + RETURNS: + if environment handle or error handle is null, return + OCI_INVALID_HANDLE. + if operation suceeds, return OCI_SUCCESS. + if operation fails, return OCI_ERROR. + */ + +/*------------------------- OCIObjectArrayPin -------------------------------*/ +sword OCIObjectArrayPin(OCIEnv *env, OCIError *err, OCIRef **ref_array, + ub4 array_size, OCIComplexObject **cor_array, + ub4 cor_array_size, OCIPinOpt pin_option, + OCIDuration pin_duration, OCILockOpt lock, + void **obj_array, ub4 *pos ); +/* + NAME: OCIObjectArrayPin - ORIO array pin + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns + OCI_ERROR. The error recorded in 'err' can be + retrieved by calling OCIErrorGet(). + ref_array (IN) - array of references to be pinned + array_size (IN) - number of elements in the array of references + pin_option (IN) - pin option. See OCIObjectPin(). + pin_duration (IN) - pin duration. See OCIObjectPin(). + lock_option (IN) - lock option. See OCIObjectPin(). + obj_array (OUT) - If this argument is not NULL, the pinned objects + will be returned in the array. The user must + allocate this array with element type being + 'void *'. The size of this array is identical to + 'array'. + pos (OUT) - If there is an error, this argument will contain + the element that is causing the error. Note that + this argument is set to 1 for the first element in + the ref_array. + REQUIRE: + - a valid OCI environment handle must be given. + - If 'obj_array' is not NULL, then it must already be allocated and + the size of 'obj_array' is 'array_size'. + DESCRIPTION: + This function pin an array of references. All the pinned objects are + retrieved from the database in one network roundtrip. If the user + specifies an output array ('obj_array'), then the address of the + pinned objects will be assigned to the elements in the array. See + OCIObjectPin() for more information about pinning. + RETURNS: + if environment handle or error handle is null, return + OCI_INVALID_HANDLE. + if operation suceeds, return OCI_SUCCESS. + if operation fails, return OCI_ERROR. + */ + +/*---------------------------------------------------------------------------*/ +/* HEAP/CACHE OPERATIONS */ +/*---------------------------------------------------------------------------*/ + +/*--------------------------- OCICacheFlush ---------------------------------*/ +sword OCICacheFlush( OCIEnv *env, OCIError *err, const OCISvcCtx *svc, + void *context, OCIRef *(*get)(void *context, ub1 *last), + OCIRef **ref ); +/* + NAME: OCICacheFlush - OCI flush persistent objects + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns + OCI_ERROR. The error recorded in 'err' can be + retrieved by calling OCIErrorGet(). + svc (IN) [optional] - OCI service context. If null pointer is + specified, then the dirty objects in all connections + will be flushed. + context (IN) [optional] - specifies an user context that is an + argument to the client callback function 'get'. This + parameter is set to NULL if there is no user context. + get (IN) [optional] - an client-defined function which acts an + iterator to retrieve a batch of dirty objects that need + to be flushed. If the function is not NULL, this function + will be called to get a reference of a dirty object. + This is repeated until a null reference is returned by + the client function or the parameter 'last' is set to + TRUE. The parameter 'context' is passed to get() + for each invocation of the client function. This + parameter should be NULL if user callback is not given. + If the object that is returned by the client function is + not a dirtied persistent object, the object is ignored. + All the objects that are returned from the client + function must be from newed or pinned the same service + context, otherwise, an error is signalled. Note that the + returned objects are flushed in the order in which they + are marked dirty. + ref (OUT) [optional] - if there is an error in flushing the + objects, (*ref) will point to the object that + is causing the error. If 'ref' is NULL, then the object + will not be returned. If '*ref' is NULL, then a + reference will be allocated and set to point to the + object. If '*ref' is not NULL, then the reference of + the object is copied into the given space. If the + error is not caused by any of the dirtied object, + the given ref is initalized to be a NULL reference + (OCIRefIsNull(*ref) is TRUE). + REQUIRES: + - a valid OCI environment handle must be given. + DESCRIPTION: + This function flushes the modified persistent objects from the + environment heap to the server. The objects are flushed in the order + that they are marked updated or deleted. + + See OCIObjectFlush() for more information about flushing. + + RETURNS: + if environment handle or error handle is null, return + OCI_INVALID_HANDLE. + if operation suceeds, return OCI_SUCCESS. + if operation fails, return OCI_ERROR. + */ + +/*--------------------------- OCICacheRefresh -------------------------------*/ +sword OCICacheRefresh(OCIEnv *env, OCIError *err, const OCISvcCtx *svc, + OCIRefreshOpt option, void *context, + OCIRef *(*get)(void *context), OCIRef **ref); +/* + NAME: OCICacheRefresh - OCI ReFreSh persistent objects + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns + OCI_ERROR. The error recorded in 'err' can be + retrieved by calling OCIErrorGet(). + svc (IN) [optional] - OCI service context. If null pointer is + specified, then the persistent objects in all connections + will be refreshed. + option (IN) [optional] - if OCI_REFRESH_LOAD is specified, all + objects that is loaded within the transaction are + refreshed. If the option is OCI_REFERSH_LOAD and the + parameter 'get' is not NULL, this function will ignore + the parameter. + context (IN) [optional] - specifies an user context that is an + argument to the client callback function 'get'. This + parameter is set to NULL if there is no user context. + get (IN) [optional] - an client-defined function which acts an + iterator to retrieve a batch of objects that need to be + refreshed. If the function is not NULL, this function + will be called to get a reference of an object. If + the reference is not NULL, then the object will be + refreshed. These steps are repeated until a null + reference is returned by this function. The parameter + 'context' is passed to get() for each invocation of the + client function. This parameter should be NULL if user + callback is not given. + ref (OUT) [optional] - if there is an error in refreshing the + objects, (*ref) will point to the object that + is causing the error. If 'ref' is NULL, then the object + will not be returned. If '*ref' is NULL, then a + reference will be allocated and set to point to the + object. If '*ref' is not NULL, then the reference of + the object is copied into the given space. If the + error is not caused by any of the object, + the given ref is initalized to be a NULL reference + (OCIRefIsNull(*ref) is TRUE). + REQUIRES: + - a valid OCI environment handle must be given. + DESCRIPTION: + This function refreshes all pinned persistent objects. All unpinned + persistent objects are freed. See OCIObjectRefresh() for more + information about refreshing. + RETURNS: + if environment handle or error handle is null, return + OCI_INVALID_HANDLE. + if operation suceeds, return OCI_SUCCESS. + if operation fails, return OCI_ERROR. + */ + +/*---------------------------- OCICacheUnpin --------------------------------*/ +sword OCICacheUnpin( OCIEnv *env, OCIError *err, const OCISvcCtx *svc ); +/* + NAME: OCICacheUnpin - OCI UNPin objects + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns + OCI_ERROR. The error recorded in 'err' can be + retrieved by calling OCIErrorGet(). + svc (IN) [optional] - OCI service context. If null pointer is + specified, then the objects in all connections + will be unpinned. + REQUIRES: + - a valid OCI environment handle must be given. + DESCRIPTION: + If a connection is specified, this function completely unpins the + persistent objects in that connection. Otherwise, all persistent + objects in the heap are completely unpinned. All transient objects in + the heap are also completely unpinned. See OCIObjectUnpin() for more + information about unpinning. + RETURNS: + if environment handle or error handle is null, return + OCI_INVALID_HANDLE. + if operation suceeds, return OCI_SUCCESS. + if operation fails, return OCI_ERROR. + */ + +/*----------------------------- OCICacheFree --------------------------------*/ +sword OCICacheFree( OCIEnv *env, OCIError *err, const OCISvcCtx *svc ); +/* + NAME: OCICacheFree - OCI FREe instances + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns + OCI_ERROR. The error recorded in 'err' can be + retrieved by calling OCIErrorGet(). + svc (IN) [optional] - OCI service context. If null pointer is + specified, then the objects in all connections + will be freed. + REQUIRES: + - a valid OCI environment handle must be given. + DESCRIPTION: + If a connection is specified, this function frees the persistent + objects, transient objects and values allocated for that connection. + Otherwise, all persistent objects, transient objects and values in the + heap are freed. Objects are freed regardless of their pin count. See + OCIObjectFree() for more information about freeing an instance. + RETURNS: + if environment handle or error handle is null, return + OCI_INVALID_HANDLE. + if operation suceeds, return OCI_SUCCESS. + if operation fails, return OCI_ERROR. +*/ + +/*---------------------------- OCICacheUnmark -------------------------------*/ +sword OCICacheUnmark( OCIEnv *env, OCIError *err, const OCISvcCtx *svc ); +/* + NAME: OCICacheUnmark - OCI Unmark all dirty objects + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns + OCI_ERROR. The error recorded in 'err' can be + retrieved by calling OCIErrorGet(). + svc (IN) [optional] - OCI service context. If null pointer is + specified, then the objects in all connections + will be unmarked. + REQUIRES: + - a valid OCI environment handle must be given. + DESCRIPTION: + If a connection is specified, this function unmarks all dirty objects + in that connection. Otherwise, all dirty objects in the cache are + unmarked. See OCIObjectUnmark() for more information about unmarking + an object. + RETURNS: + if environment handle or error handle is null, return + OCI_INVALID_HANDLE. + if operation suceeds, return OCI_SUCCESS. + if operation fails, return OCI_ERROR. + */ + + +sword OCIDurationBegin( OCIEnv *env, OCIError *err, const OCISvcCtx *svc, + OCIDuration parent, OCIDuration *dur ); +/* + NAME: OCIDurationBegin - OCI DURATION BEGIN + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + This should be passed NULL, when cartridge services + are to be used. + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + svc (IN/OUT) - OCI service handle. + parent (IN) - parent for the duration to be started. + dur (OUT) - newly created user duration + REQUIRES: + - a valid OCI environment handle must be given for non-cartridge + services. + - For cartridge services, NULL should be given for environment handle + - A valid service handle must be given in all cases. + DESCRIPTION: + This function starts a new user duration. A user can have multiple + active user durations simultaneously. The user durations do not have + to be nested. + + The object subsystem predefines 3 durations : + 1) session - memory allocated with session duration comes from + the UGA heap (OCI_DURATION_SESSION). A session + duration terminates at the end of the user session. + 2) transaction - memory allocated with transaction duration comes + from the UGA heap (OCI_DURATION_TRANS). A trans- + action duration terminates at the end of the user + transaction. + 3) call - memory allocated with call duration comes from PGA + heap (OCI_DURATION_CALL). A call duration terminates + at the end of the user call. + + Each user duration has a parent duration. A parent duration can be a + predefined duration or another user duration. The relationship between + a user duration and its parent duration (child duration) are: + + 1) An user duration is nested within the parent duration. When its + parent duration terminates, the user duration will also terminate. + 2) The memory allocated with an user duration comes from the heap of + its parent duration. For example, if the parent duration of an + user duration is call, then the memory allocated with the user + duration will also come from the PGA heap. + + This function can be used as both part of cartridge services as well + as without cartridge services. + The difference in the function in the case of cartridge and + non-cartridge services is: + In case of cartridge services, as descibed above a new user + duration is created as a child of the "parent" duration. + But when used for non-cartridge purposes, when a pre-defined + duration is passed in as parent, it is mapped to the cache duration + for that connection (which is created if not already present) and + the new user duration will be child of the cache duration. + + RETURNS: + if environment handle and service handle is null or if error + handle is null return OCI_INVALID_HANDLE. + if operation suceeds, return OCI_SUCCESS. + if operation fails, return OCI_ERROR. + */ + + +sword OCIDurationEnd( OCIEnv *env, OCIError *err, const OCISvcCtx *svc, + OCIDuration duration ); +/* + NAME: OCIDurationEnd - OCI DURATION END + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + This should be passed NULL, when cartridge services + are to be used. + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + svc (IN/OUT) - OCI service handle. + dur (OUT) - a previously created user duration using + OCIDurationBegin() + REQUIRES: + - a valid OCI environment handle must be given for non-cartridge + services. + - For cartridge services, NULL should be given for environment handle + - A valid service handle must be given in all cases. + DESCRIPTION: + This function terminates a user duration. All memory allocated for + this duration is freed. + + This function can be used as both part of cartridge services as well + as without cartridge services. In both cased, the heap duration + is freed and all the allocated memory for that duration is freed. + The difference in the function in the case of cartridge and + non-cartridge services is: + In case of non-cartridge services, if the duration is pre- + defined, the associated cache duration (see OCIDurationBegin()) + is also terminated and the following is done. + 1) The child durations are terminated. + 2) All objects pinned for this duration are unpinned. + 3) All instances allocated for this duration are freed. + + In case of cartridge services, only the heap duration is + freed. All the context entries allocated for that duration are + freed from the context hash table.. + + RETURNS: + if environment handle and service handle is null or if error + handle is null return OCI_INVALID_HANDLE. + if operation suceeds, return OCI_SUCCESS. + if operation fails, return OCI_ERROR. + */ + +/****************************************************************************** +** DO NOT USE THE FUNCTIONS BELOW! ** +** UNSUPPORTED INTERFACE ** +** WILL BE REMOVED/CHANGED IN A FUTURE RELEASE ** +******************************************************************************/ + +sword OCIDurationGetParent( OCIEnv *env, OCIError *err, + OCIDuration duration, OCIDuration *parent ); + +sword OCIObjectAlwaysLatest( OCIEnv *env, OCIError *err, void *object ); + +sword OCIObjectNotAlwaysLatest( OCIEnv *env, OCIError *err, + void *object ); + +sword OCIObjectFlushRefresh( OCIEnv *env, OCIError *err, void *object); + +sword OCIObjectIsLoaded( OCIEnv *env, OCIError *err, void *ins, + boolean *load); + +sword OCIObjectIsDirtied( OCIEnv *env, OCIError *err, void *ins, + boolean *dirty); + +sword OCICacheGetObjects( OCIEnv *env, OCIError *err, + const OCISvcCtx *svc, + OCIObjectProperty property, + void *client_context, + void (*client_callback)( + void *client_context, + void *object )); + +sword OCICacheRegister( OCIEnv *env, OCIError *err, + OCIObjectEvent event, + void *client_context, + void (*client_callback)( + void *client_context, + OCIObjectEvent event, + void *object)); + +sword OCICacheFlushRefresh( OCIEnv *env, OCIError *err, + const OCISvcCtx *svc, void *context, + OCIRef *(*get)(void *context, ub1 *last), + OCIRef **ref ); + +sword OCIObjectSetData(OCIEnv *env, OCIError *err, void *obj_hdr, + void *data); + +sword OCIObjectGetNewOID(OCIEnv *env, OCIError *err, OCISvcCtx *svc, + ub1 *oid); + + +#endif /* ORI_ORACLE */ diff --git a/OCI/include/orid.h b/OCI/include/orid.h new file mode 100644 index 0000000..a105f64 --- /dev/null +++ b/OCI/include/orid.h @@ -0,0 +1,373 @@ +/* Copyright (c) 1994, 2006, Oracle. All rights reserved. */ + +/* + Author: Tin Nguyen + Date: 02/07/94 + Source documents: "Functional Specification for C Object Interface, Object + Management Subsystem", "Oracle C Coding Standards + version 2.2", and the header file template + Rule sets: the generic and .h file rule sets + Quality status: not exited + Identification tag: [ one or more letters to identify the .h file ] + Revision code: [ date of the last revision of the .h file ] + + Note to the user of this header file: + + Anything in this header file that is marked private is not supported and + must not be used. Private sections are included in the header file to + improve internal maintenance. + + NAME + + ORID - Oracle Object Interface for Dynamic Data Access + + DESCRIPTION + + This file contains declarations for C object interface functions including + the dynamic object data access operations that allow callers to dynamically + access and manipulate objects; these operations include getting and setting + attributes of an object. These dynamic object operations are for accessing + and manipulation objects whose types are not known at compile-time. + + RELATED DOCUMENTS + + Functional Specification for C Object Interface / Object Management System + + PUBLIC FUNCTIONS + + OCIObjectSetAttr - ORID SET attribute value + OCIObjectGetAttr - ORID GET attribute value + + PRIVATE FUNCTIONS + + None + + EXAMPLES + + EXAMPLE 1 + + /o + o This example illustrates how an interative program can use the dynamic + o attribute access to display and modify attributes of an ADT instance. + o The interactive program does not know the type of the object at + o compile time. + o/ + + void display(adt_ref, object, null_struct, names, names_count, + names_length, indexes, indexes_count) + { + /o Pin the ADT o/ + if (OCIObjectPin(env, &adt_ref, OROOPOCUR, OROOPDTRA, OROOLMNON, &adt) + != OROSTASUC) + /o error handling code o/ + + /o + o Call the type manager to obtain all the attributes in the object. + o Display the content of each attribute in the ADT instance. If the + o attribute is an array, display each element of the array. If the + o attribute is an ADT instance, recursively call this routine to + o display the embedded ADT instance. + o/ + numAttrs = OCITypeAttrs(env, adt); + for (i= 1; i <= numAttrs; i++) + { + /o get attribute descriptor o/ + if (ortgabp(env, adt, i, &ado_ref, &ado) != OROSTASUC) + /o error handling code o/ + + /o get attribute name o/ + names[names_count] = OCITypeElemName(env, ado, + &names_length[names_count]); + + /o dynamically get the attr o/ + if (OCIObjectGetAttr(env, object, null_struct, 0, adt_ref, names, + names_length, names_count+1, indexes, indexes_count, 0, + &null, &null_info, &attr) != OROSTASUC) + /o error handling code o/ + + /o check if attribute is null o/ + if (null) continue; + + /o get typecode of attribute o/ + typecode = OCITypeElemTypeCode(env, ado); + + /o if attribute is a varray, display each element in varray o/ + if (typecode == OCI_TYPECODE_VARRAY) + { + /o get the reference to the type of the element of the array o/ + if (OCITypeElemParameterizedTyper(env, ado, &attr_type_ref) + != OROSTASUC) + /o error handling code o/ + + /o get the size of array o/ + if (orlasiz(env, &attr_type_ref, (orlva *)attr, + &numElm) != OROSTASUC) + /o error handling code o/ + + /o get the typecode of the element of the array o/ + if (ortty2r(env, attr_type_ref, &typecode) != OROSTASUC) + /o error handling code o/ + + /o iterate the array o/ + for (j=0; j < numElm; j++) + { + /o get an element in the array o/ + if (OCIObjectGetAttr(env, attr, null_info, j+1, attr_type_ref, + names, names_length, 0, indexes, 0, 0, &null, &null_info, + &element) != OROSTASUC) + /o error handling code o/ + + /o check if element is null o/ + if (null) continue; + + /o if attr is an ADT instance, recursively call this routine o/ + if (typecode == OCI_TYPECODE_ADT || typecode == + OCI_TYPECODE_UNNAMEDADT) + { + /o display the element as an adt o/ + display(attr_type_ref, element, null_info, names, lengths, + 0, indexes, 0); + } + + /o if attribute is scalar, print the value to the screen o/ + else output_to_screen(element, typecode); + } + } + + /o if attribute is an ADT instance, recursively call this routine o/ + else if (typecode == OCI_TYPECODE_ADT || typecode == + OCI_TYPECODE_UNNAMEDADT) + { + /o get the type ref of the attribute o/ + if (ortgarf(env, ado, &attr_type_ref) != OROSTASUC) + /o error handling code o/ + + display(attr_type_ref, attr, null_info, 0, names, 0, names_length, + indexes, 0); + } + + /o if attribute is scalar, print the value to the screen o/ + else output_to_screen(attr, typecode); + } + } + + /o ******** main routine *********** o/ + .... + + /o + o Allocate the arrays for storing the path expression + o/ + + /o get the tdo of type 'long' o/ + if (orttypget(&env, con, "SYS", sizeof("SYS"), "SINT32", sizeof("SINT32"), + OROOPDSES, &long_ref, &long_tdo) != OROSTASUC) + /o error handling code o/ + + /o get the tdo of type 'varchar' o/ + if (orttypget(&env, con, "SYS", sizeof("SYS"), "SQL_VARCHAR2", + sizeof("SQL_VARCHAR2"), OROOPDSES, &vchar_ref, &vchar_tdo) + != OROSTASUC) + /o error handling code o/ + + /o allocate the varrays for the path expression o/ + if (orlalloc(env, &vchar_ref, MAX_ARR_SIZE, &attr_names) != OROSTASUC) + /o error handling code o/ + + if (orlalloc(env, &long_ref, MAX_ARR_SIZE, &attr_name_lengths) + != OROSTASUC) + /o error handling code o/ + + if (orlalloc(env, &long_ref, MAX_ARR_SIZE, &attr_name_indexes) + != OROSTASUC) + /o error handling code o/ + + /o + o Get an ADT instance. The ref to the ADT instance can be obtained + o by through ORI or OSCI. + o/ + if (OCIObjectPin(env, &obj_ref, OROOPOCUR, OROOPDTRA, OROOLMUPD, &object) + != OROSTASUC) + /o error handling code o/ + + /o get the null structure of the ADT instance o/ + if (OCIObjectGetInd(gp, object, &null_struct) != OROSTASUC) + /o error handling code o/ + + /o + o Get the type of the ADT instance + o/ + + /o find out the type of the ADT instance o/ + if (oriogto(env, object, &adt_ref) != OROSTASUC) + /o error handling code o/ + + /o display the object o/ + display(adt_ref, object, null_struct, attr_names, 0, attr_names_lengths, + attr_names_indexes, 0); + + /o After the object is displayed, the program waits for the user to + o respond. The user modifies the values of an attribute and the + o program generates a path expression for the attribute and calls + o OCIObjectSetAttr() to set the value. + o/ + + if (OCIObjectSetAttr(env, object, null_struct, adt_ref, + (text **)attr_names, (ub4 *)attr_name_lengths, + attr_names_count, (ub4 *)attr_array_indexes, + attr_array_indexes_count, + (void *)0, FALSE, (void *)value) != OROSTASUC) + /o error handling code o/ + + END OF EXAMPLE 1 + + NOTES + + This file has been subsetted to contain only the routines that will + be in the first release. + + MODIFIED + dmukhin 06/29/05 - ANSI prototypes; miscellaneous cleanup + srseshad 03/12/03 - convert oci public api to ansi + aahluwal 06/03/02 - bug 2360115 + bpalaval 02/09/01 - Change text to oratext. + whe 09/01/99 - 976457:check __cplusplus for C++ code + sthakur 09/18/97 - collection indexing not supported + cxcheng 08/05/97 - fix compile with short names + skrishna 03/18/97 - fix ifdef for supporting ansi and k&r proto-types + cxcheng 02/06/97 - take out short name support except with SLSHORTNAME + cxcheng 10/17/96 - final renaming of functions + jboonleu 10/07/96 - beautify with OCI long names + cxcheng 10/07/96 - change short names to long names for readability + jboonleu 09/27/96 - fix lint + jwijaya 07/03/96 - add ANSI prototypes + jboonleu 04/13/95 - new interface + jwijaya 10/11/94 - fix the sccs header and add namespace + tanguyen 08/22/94 - fix example + tanguyen 08/09/94 - remove Sccsid declaration + tanguyen 07/20/94 - fix OCIObjectSetAttr and OCIObjectGetAttr to + use position descriptor + tanguyen 07/18/94 - change 'object' type to become ptr to object + tanguyen 06/30/94 - Fix the ORID_ORACLE ifdef + tanguyen 06/27/94 - update to template format + skotsovo 05/12/94 - replace ado with attribute position + jweisz 05/11/94 - test new checkin facility + jwijaya 05/05/94 - orienv/ref/typ -> oroenv/ref/typ + jwijaya 02/07/94 - Creation + +*/ + +#ifndef ORATYPES +#include +#endif +#ifndef ORO_ORACLE +#include +#endif +#ifndef OCI_ORACLE +#include +#endif + +#ifndef ORID_ORACLE +#define ORID_ORACLE + +#ifdef SLSHORTNAME + +#define OCIObjectSetAttr oridset +#define OCIObjectGetAttr oridget + +#endif /* SLSHORTNAME */ + +/*---------------------------------------------------------------------------*/ +/* PUBLIC FUNCTIONS */ +/*---------------------------------------------------------------------------*/ + +/*-------------------------- OCIObjectSetAttr ----------------------------*/ +sword OCIObjectSetAttr( OCIEnv *env, OCIError *err, void *instance, + void *null_struct, struct OCIType *tdo, + const oratext **names, const ub4 *lengths, + const ub4 name_count, const ub4 *indexes, + const ub4 index_count, const OCIInd null_status, + const void *attr_null_struct, const void *attr_value ); +/* + NAME: OCIObjectSetAttr - ORID SET value + PARAMETERS: + env (IN) - OCI environment handle initialized in object mode + err (IN) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + instance (IN) - pointer to an ADT instance + null_struct (IN) - the null structure of the ADT instance or array + tdo (IN) - pointer to the TDO + names (IN) - array of attribute names. This is used to specify + the names of the attributes in the path expression. + lengths (IN) - array of lengths of attribute names. + name_count (IN) - number of element in the array 'names'. + indexes (IN) [OPTIONAL] - currently NOT SUPPORTED, pass (ub4 *)0. + index_count (IN) [OPTIONAL] - currently NOT SUPPORTED, pass (ub4)0. + attr_null_status (IN) - the null status of the attribute if the type of + attribute is primitive. + attr_null_struct (IN) - the null structure of an ADT or collection + attribute. + attr_value (IN) - pointer to the attribute value. + REQUIRES: + DESCRIPTION: + This function set the attribute of the given object with the given + value. The position of the attribute is specified as a path + expression which is an array of names and an array of indexes. + RETURNS: + one of OROSTA* + EXAMPLES: + For path expression stanford.cs.stu[5].addr, the arrays will look like + names = {"stanford", "cs", "stu", "addr"} + lengths = {8, 2, 3, 4} + indexes = {5} + + Also see the above example. + */ + +/*-------------------------- OCIObjectGetAttr ----------------------------*/ +sword OCIObjectGetAttr( OCIEnv *env, OCIError *err, void *instance, + void *null_struct, struct OCIType *tdo, + const oratext **names, const ub4 *lengths, + const ub4 name_count, const ub4 *indexes, + const ub4 index_count, OCIInd *attr_null_status, + void **attr_null_struct, void **attr_value, + struct OCIType **attr_tdo ); +/* + NAME: OCIObjectGetAttr - ORID GET value + PARAMETERS: + env (IN) - OCI environment handle initialized in object mode + err (IN) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + instance (IN) - pointer to an ADT instance + null_struct (IN) - the null structure of the ADT instance or array + tdo (IN) - pointer to the TDO + names (IN) - array of attribute names. This is used to specify + the names of the attributes in the path expression. + lengths (IN) - array of lengths of attribute names. + name_count (IN) - number of element in the array 'names'. + indexes (IN) [OPTIONAL] - currently NOT SUPPORTED, pass (ub4 *)0. + index_count (IN) [OPTIONAL] - currently NOT SUPPORTED, pass (ub4)0. + attr_null_status (OUT) - the null status of the attribute if the type + of attribute is primitive. + attr_null_struct (OUT) - the null structure of an ADT or collection + attribute. + attr_value (OUT) - pointer to the attribute value. + attr_tdo (OUT) - pointer to the TDO of the attribute. + REQUIRES: + - a valid OCI environment handle must be given. + DESCRIPTION: + This function gets a value from an ADT instance or from an array. + If the parameter 'instance' points to an ADT instance, then the path + expression specifies the location of the attribute in the ADT. + It is assumed that the object is pinned and that the value returned + is valid until the object is unpinned. + RETURNS: + one of OROSTA* + EXAMPLES: + See example in OCIObjectSetAttr(). Also see the above example. + */ + +#endif /* ORID_ORACLE */ diff --git a/OCI/include/orl.h b/OCI/include/orl.h new file mode 100644 index 0000000..5aa3d88 --- /dev/null +++ b/OCI/include/orl.h @@ -0,0 +1,3633 @@ +/* Copyright (c) 1993, 2006, Oracle. All rights reserved. */ + +/* + Author: Srinath Krishnaswamy + Date: 11/24/93 + Source documents: "Functional Specification for C Language Mapping of + OTS Types, Object Management Subsystem", "Oracle C + Coding Standards version 2.2", and the header file + template + Rule sets: the generic and .h file rule sets + Quality status: not exited + Identification tag: [ one or more letters to identify the .h file ] + Revision code: 11/24/93 + + NAME + + ORL - ORacle's external C Language interface to primitive OTS types + + DESCRIPTION + + This header file contains C langauge interface to the OTS primitive + types. The interface includes C mapping of OTS primitive types and + the prototype of the pre-defined operations on the primitive types. + + *********************************************************************** + *** NOTE: The OCI functions for objects requires the *** + *** application to be running in OBJECT mode. That is, during *** + *** process initialization OCIInitialize(), the mode *** + *** specified should be OBJECT mode. *** + ** OCIInitialize(OCI_OBJECT, ..); *** + *********************************************************************** + + RELATED DOCUMENTS + + [1] Krishnaswamy, Srinath and Nguyen, Tin A., "Functional Specification + for C Language Mapping of OTS Types, Object Management Subsystem", + March 1994. + [2] Nguyen, Tin A., "The Open Type System", Oracle Corporation, + February 1994. + [3] Klein, Jonathan D., "Large Field Management", Oracle Corporation, + October 1993. + + PUBLIC FUNCTIONS + + OCI - OCI functions to manipulate Oracle Number, float and decimal + ARITHMETIC + OCINumberInc - OCINumber INCrement (optimized) + OCINumberDec - OCINumber DECrement (optimized) + OCINumberAdd - OCINumber ADD numbers + OCINumberSub - OCINumber SUBtract numbers + OCINumberMul - OCINumber MULtiply numbers + OCINumberDiv - OCINumber DIVide numbers + OCINumberMod - OCINumber MODulo division + OCINumberIntPower - OCINumber integer PoWeR + OCINumberShift - OCINumber decimal ShiFT number + OCINumberNeg - OCINumber NEGate number + OCINumberAbs - OCINumber ABSolute value + OCINumberCeil - OCINumber CEiling of number + OCINumberFloor - OCINumber FLooR of number + OCINumberSqrt - OCINumber SQuare Root of number + OCINumberSign - OCINumber get SIGN of number + NATIVE TYPE CONVERSION + OCINumberToInt - OCINumber convert number TO machine-format Integer + OCINumberFromInt - OCINumber convert machine-format Integer TO Number + OCINumberToReal - OCINumber convert number TO machine-format Real + OCINumberToRealArray - OCINumber convert array of numbers TO + machine-format Real + OCINumberFromReal - OCINumber convert machine-format Real TO Number + TEXT STRING CONVERSION + OCINumberToText - OCINumber convert number TO String + OCINumberFromText - OCINumber convert String TO Number + COMPARISON + OCINumberCmp - OCINumber CoMPare numbers + OCINumberIsZero - OCINumber comparison with ZERo + OCINumberIsInt - OCINumber Is an Integer + ASSIGNMENT + OCINumberAssign - OCINumber ASsiGn number + OCINumberSetZero - OCINumber Set number to Zero value + OCINumberSetPi - OCINumber Set number to Pi + ROUNDING + OCINumberTrunc - OCINumber TRUncate an Oracle number + OCINumberRound - OCINumber ROUnd number + OCINumberPrec - OCINumber round to Precision digits + TRANSCENDENTAL + OCINumberSin - OCINumber SINe + OCINumberArcSin - OCINumber Arc SINe + OCINumberHypSin - OCINumber SiNe Hyperbolic + OCINumberCos - OCINumber COSine + OCINumberArcCos - OCINumber Arc COSine + OCINumberHypCos - OCINumber CoSine Hyperbolic + OCINumberTan - OCINumber TANgent + OCINumberArcTan - OCINumber Arc TANgent + OCINumberArcTan2 - OCINumber Arc TaNgent 2 + OCINumberHypTan - OCINumber TaNgent Hyperbolic + OCINumberPower - OCINumber arbitrary Base EXponentiation + OCINumberExp - OCINumber EXPonentiation to base e + OCINumberLn - OCINumber Logarithm Natural + OCINumberLog - OCINumber LOGarithm to arbitrary base + + OCIDate - OCI functions to manipulate OCI Date + OCIDateToExternal - OCIDate convert date to external form + OCIDateFromExternal - OCIDate convert external form of date into OCIDate + OCIDateAssign - OCIDate Assignment + OCIDateToText - OCIDate convert date TO String + OCIDateFromText - OCIDate convert String TO Date + OCIDateZoneToZone - OCIDate convert date from one time + Zone TO another Zone + OCIDateCompare - OCIDate CoMPare dates + OCIDateAddMonths - OCIDate ADd or subtract Months + OCIDateAddDays - OCIDate ADd or subtract Days + OCIDateLastDay - OCIDate get date of LaST day of month + OCIDateDaysBetween - OCIDate get number of days BeTWeen two dates + OCIDateNextDay - OCIDate get date of Next DaY + OCIDateCheck - OCIDate CHecK if the given date is valid + OCIDateSysDate - OCIDate get current SYStem date and time + + OCIString - OCI String functions to manipulate Variable-length string + OCIStringAssign - OCIString Assign string to string + OCIStringAssignText - OCIString Assign Text string to string + OCIStringResize - OCIString ReSiZe string + OCIStringSize - OCIString get String Size + OCIStringPtr - OCIString get String PoinTeR + OCIStringAllocSize - OCIString get Allocated SiZe + + OCIRaw - OCI Raw functions to manipulate variable-length raW + OCIRawAssignRaw - OCIRaw Assign Raw (of type OCIRaw*) to raw + (of type OCIRaw*) + OCIRawResize - OCIRaw Resize raw + OCIRawSize - OCIRaw get Raw Size + OCIRawPtr - OCIRaw get Raw data Pointer + OCIRawAllocSize - OCIRaw get Allocated Size + + OCIColl - OCI Collection generic functions. These functions can be + used to manipulate both variable-length array (varray) and + nested table. + OCICollSize - OCIColl return current SIZe of the given collection + (in number of elements) + OCICollMax - OCIColl return the MAXimum number of elements in the + collection (i.e. upper-bound) + OCICollGetElem - OCIColl GET pointer to the element at the given + position + OCICollAssignElem - OCIColl assign to element at given index + OCICollAssign - OCIColl ASsiGn collection; perform deep-copy of source + collection to target collection + OCICollAppend - OCIColl aPPend the given element to the end of the + collection + OCICollTrim - OCIColl trim (delete) the given number of elements + from the end of the collection + OCICollIsLocator - OCIColl indicates whether a collection is locator + based or not. + OCIIterCreate - OCIColl Create an ITerator to scan the collection + elements + OCIIterDelete - OCIColl Delete ITerator + OCIIterInit - OCIColl Initialize ITerator to scan the given collection + OCIIterGetCurrent - OCIColl Iterator based, get CURrent + collection element + OCIIterNext - OCIColl Iterator based, get NeXT collection element + OCIIterPrev - OCIColl Iterator based, get PReVious collection element + + OCITable - OCI functions to manipulate nested Table. The OCIColl*() and + OCITable*() functions can be used to manipulate nested table + OCITableDelete(i) - OCITable if element(i) exists then the element is + marked as deleted else the function returns false. So + delete's create "holes". + OCITableExists(i) - OCITable return true iff an element at + position i EXIsts + OCITableFirst - OCITable return the smallest value of i for which + exists(i) is true. + OCITableLast - OCITable return the largest value of i for which + exists(i) is true. + OCITableNext(i) - OCITable return pointer to the smallest position j, + greater than i, such that OCITableExists(j) is true + OCITablePrev(i) - OCITable return pointer to the largest position j, + less than i, such that OCITableExists(j) is true + OCITableSize - OCITable return current SIZe of the given nested table not + including deleted elements + + OCIRef - OCI functions to manipulate object Reference + OCIRefClear - OCIRef CLeaR or nullify a ref + OCIRefAssign - OCIRef ASsiGn a ref to another + OCIRefIsEqual - OCIRef compare two refs for EQUality + OCIRefIsNull - OCIRef test if a ref is NULl + OCIRefFromHex - OCIRef convert a Hexadecimal string TO a Ref + OCIRefToHex - OCIRef convert a ref to a Hexadecimal string + OCIRefHexSize - OCIRef get size of buffer in bytes to store hexadecimal + string + + OBSOLETE: to be replaced by functions from oci.h: + + ORLL - ORL functions to manipulate lob Locators + orllasg - ORLL AsiGn one locator to another + orllequ - ORLL compare two locators for EQUality + orlliini - ORLL Is the locator INItialized? + orllgsz - ORLL Get locator SiZe + orllgcid - ORLL Get Character set ID + + NOTE: The following are specific to FILE lobs: + + orllsnm - ORLL Set directory alias and file NaMe in the locator + orllgnm - ORLL Get directory alias and file NaMe from the locator + + EXAMPLES + + Examples are given in the description of each function where + relevant. + + NOTES + + This file has been subsetted to contain ONLY the routines that will + be in the first release. + + QUESTIONS + + MODIFIED + bkhaladk 08/01/05 - add defn for OCIBinXmlReposCtx + dmukhin 06/29/05 - ANSI prototypes; miscellaneous cleanup + srseshad 03/12/03 - convert oci public api to ansi + rpingte 11/21/02 - Add OCICollGetElemArray and OCINumberToRealArray + aahluwal 06/03/02 - bug 2360115 + gayyappa 02/01/02 - fix 2210776 : change Dom to DOM + whe 09/25/01 - add OCIXMLType & OCIDomDocument opaque types + bpalaval 02/09/01 - Change text to oratext. + rkasamse 09/20/99 - lint changes + whe 09/01/99 - 976457:check __cplusplus for C++ code + hsbedi 08/11/99 - Add macro + rxgovind 10/14/98 - make non exposed calls (OCIRowType etc) private + rxgovind 06/09/98 - update OCIRowTypeCreate + nmantrav 05/11/98 - add OCIRowTypeGetCount + rxgovind 03/29/98 - add OCIRowType and OCIRowData interfaces + jwijaya 05/06/98 - add OCICollIsLocator + rxgovind 03/18/98 - opaque types: move to kolo.h + etucker 02/02/98 - add comments for Dec and Inc + etucker 01/29/98 - Finish core5 integration + rxgovind 11/11/97 - opaque types + etucker 10/28/97 - add ORLN functions for SDK + cxcheng 07/28/97 - remove OCILobLocator #define + skmishra 05/13/97 - stdcc compatibility changes + skrishna 04/25/97 - rename OCINumber*(): Exp Power TanHyp Zero Init + TanToArc Sqr Truncate and Compare + skotsovo 03/31/97 - remove OCILobLocatorSize + skrishna 03/25/97 - remove orld2i and orldi2d + skrishna 03/18/97 - fix ifdef for supporting ansi and k&r proto-types + cxcheng 02/06/97 - take out short name support except with SLSHORTNAME + skrishna 01/06/97 - update OCITableSize() comments + skrishna 12/27/96 - fix OCIDateGet/OCIDateSet + skrishna 12/12/96 - update OCICollGelElem comments + skrishna 11/07/96 - OCICollGetElem: interface change + skrishna 11/05/96 - add OCIDate Get/Set and OCIDateAssign + cxcheng 10/31/96 - change OCINumberTanHyp to OCINumberHypTan + cxcheng 10/30/96 - #define orll short names to long names + dchatter 10/26/96 - fix some OCI file long names + cxcheng 10/24/96 - remove unnecessary comment in front + cxcheng 10/14/96 - disable long name mapping for LOB functions + skrishna 10/13/96 - continue beautification + skotsovo 10/16/96 - update ocilob names + cxcheng 10/09/96 - add structure members in #define for date/time + cxcheng 10/09/96 - more lint fixes + skrishna 10/09/96 - continue beautification + cxcheng 10/09/96 - more fixes + skrishna 10/09/96 - change fixed-char rep. to orlvstr* + jwijaya 10/08/96 - continue beautification + jwijaya 10/07/96 - beautify + cxcheng 10/07/96 - more changes + cxcheng 10/04/96 - replace short names with long names + skrishna 10/01/96 - orlcsiz, orltsiz: change prototype to take errhdl + skrishna 09/23/96 - fix lint errors + skotsovo 09/23/96 - remove orllmkcur(). + jwijaya 09/17/96 - comments on null ref + skrishna 09/19/96 - change orlraw format + skotsovo 09/19/96 - add orlliini and remove orllnul + skrishna 08/14/96 - orlvstr: change format to ub4 followed by text + jboonleu 08/06/96 - update comment + skotsovo 08/08/96 - revert to locators instead of descriptors as input t + jboonleu 07/23/96 - remove orlrcur + skrishna 07/06/96 - add orltsiz + skrishna 07/05/96 - add orld2i and orldi2d + jwijaya 07/03/96 - add ANSI prototypes + skrishna 06/27/96 - document default string format in orlds2d & orld2s + skrishna 06/25/96 - change max date value + skrishna 06/18/96 - modify orld2s() comments + skotsovo 06/13/96 - orll functions take lob descriptors instead of locat + rxgovind 06/05/96 - change prototype of orlrcur to take ocienvh + skrishna 05/30/96 - support collection trimming + skrishna 05/30/96 - remove orlralo/fre and orllalo/fre instead use + orionew/fre + skrishna 05/28/96 - add orlt*() and modify orla*() + skotsovo 05/23/96 - add orlbl typedefs for pro*c + jboonleu 05/14/96 - add orlrcur + rxgovind 05/08/96 - changes for 3gl callbacks + skotsovo 05/01/96 - in orllasg, no need to alloc orlbl* + skrishna 04/21/96 - merge changes from 960418 object branch into big + skrishna 04/17/96 - rename orlrcpy to orlrasg + skrishna 04/12/96 - add orlr2h and orlrh2r functions + skotsovo 04/15/96 - add fnt to make the lob locator current + skrishna 04/08/96 - change orl*() to take ocienvh* and ocierrh* instead + of oroenv* + skotsovo 03/22/96 - add locator functions + skotsovo 03/22/96 - add locator functions + skrishna 02/27/96 - remove mlslabel interface + skotsovo 02/20/96 - remove orlbty and use dty type instead. + skotsovo 02/14/96 - add text file lobs. + skrishna 01/31/96 - update comments of orln2r, orldchk, orlds2d & orld2s + skrishna 01/31/96 - change orld2s() and orln2s() to return string length + skrishna 01/21/96 - remove old raw interface + skrishna 12/14/95 - add raw interface + skotsovo 01/03/96 - change LOB offsets and lengths from ub4 to ubig_ora + to support 64 bit machines. + skotsovo 10/30/95 - add orlblsiz() to get lob locator size + skrishna 10/24/95 - move ref functions from ori and update the ref + functions to support variable-length ref + cxcheng 10/20/95 - add more comments on number versions + cxcheng 10/13/95 - add more number functions + cxcheng 08/29/95 - Support for segmented varrays + cxcheng 08/18/95 - modifiy orlmls structure + skrishna 06/06/95 - rename orln, orld, orlvs and orlva to orlnum, + orldat, orlvstr and orlvary respectively + skrishna 11/15/94 - remove orlnget() function + skrishna 09/20/94 - modify orldbtw() to return number of days only + skrishna 08/24/94 - change format string length type from ub4 to ub1 + skrishna 07/19/94 - Rename orln2c & orlnc2n to orln2s & orlns2n + skrishna 06/29/94 - Add blob interface; add examples + skrishna 06/23/94 - Update comments and format + skrishna 05/19/94 - update varray append comments + skrishna 05/05/94 - Subsetting + skrishna 11/24/93 - Creation +*/ + +#ifndef ORATYPES +#include +#endif + +#ifndef ORO_ORACLE +#include +#endif + +#ifndef ORT_ORACLE +#include +#endif + +#ifndef OCI_ORACLE +#include +#endif + +#ifndef ORL_ORACLE +#define ORL_ORACLE + +/*---------------------------------------------------------------------------*/ +/* SHORT NAMES SUPPORT SECTION */ +/*---------------------------------------------------------------------------*/ + +#ifdef SLSHORTNAME + +/* the following are short names that are only supported on IBM mainframes + with the SLSHORTNAME defined. + With this all subsequent long names will actually be substituted with + the short names here */ + +#define OCIArray orlvary +#define OCIColl orlcol +#define OCICollAppend orlcapp +#define OCICollAssign orlcasg +#define OCICollAssignElem orlcase +#define OCICollGetElem orlcget +#define OCICollGetElemArray orlcgeta +#define OCICollMax orlcmax +#define OCICollSize orlcsiz +#define OCICollTrim orlctrm +#define OCICollIsLocator orlcilc +#define OCIDate orldat +#define OCIDateAddDays orldadd +#define OCIDateAddMonths orldadm +#define OCIDateCheck orldchk +#define OCIDateCompare orldcmp +#define OCIDateDD day_orldat +#define OCIDateDaysBetween orldbtw +#define OCIDateFromText orlds2d +#define OCIDateLastDay orldlst +#define OCIDateMM mon_orldat +#define OCIDateNextDay orldndy +#define OCIDateSysDate orldsys +#define OCIDateTime time_orldat +#define OCIDateYYYY gye_orldat +#define OCIDateZoneToZone orldz2z +#define OCIIter orlcitr +#define OCIIterCreate orlccit +#define OCIIterDelete orlcdit +#define OCIIterGetCurrent orlcicur +#define OCIIterInit orlciit +#define OCIIterNext orlcinxt +#define OCIIterPrev orlciprv +#define OCINumber orlnum +#define OCINumberAbs orlnabs +#define OCINumberAdd orlnadd +#define OCINumberArcCos orlnacos +#define OCINumberArcSin orlnasin +#define OCINumberArcTan orlnatan +#define OCINumberAssign orlnasg +#define OCINumberCeil orlncel +#define OCINumberCos orlncos +#define OCINumberDiv orlndiv +#define OCINumberPower orlnbex +#define OCINumberFloor orlnflr +#define OCINumberFromInt orlni2n +#define OCINumberFromReal orlnr2n +#define OCINumberFromText orlns2n +#define OCINumberHypCos orlncsh +#define OCINumberHypSin orlnsnh +#define OCINumberSetZero orlnini +#define OCINumberSetPi orlnspi +#define OCINumberInc orlninc +#define OCINumberDec orlndec +#define OCINumberIntPower orlnpwr +#define OCINumberLn orlnln +#define OCINumberLog orlnlog +#define OCINumberMod orlnmod +#define OCINumberMul orlnmul +#define OCINumberNeg orlnneg +#define OCINumberPart orlnpart +#define OCINumberExp orlnexp +#define OCINumberRound orlnrou +#define OCINumberPrec orlnpre +#define OCINumberShift orlnsft +#define OCINumberSign orlnsgn +#define OCINumberSin orlnsin +#define OCINumberSqrt orlnsqr +#define OCINumberSub orlnsub +#define OCINumberTan orlntan +#define OCINumberHypTan orlntnh +#define OCINumberArcTan2 orlnatn2 +#define OCINumberToInt orln2i +#define OCINumberToReal orln2r +#define OCINumberToRealArray orln2ra +#define OCINumberToText orln2s +#define OCINumberTrunc orlntru +#define OCINumberCmp orlncmp +#define OCINumberIsZero orlnzer +#define OCINumberIsInt orlnint +#define OCIRaw orlraw +#define OCIRawAllocSize orlwasz +#define OCIRawAssignBytes orlwabr +#define OCIRawAssignRaw orlwarr +#define OCIRawPtr orlwgrp +#define OCIRawResize orlwrsz +#define OCIRawSize orlwgsz +#define OCIRefAssign orlrasg +#define OCIRefClear orlrclr +#define OCIRefFromHex orlrh2r +#define OCIRefHexSize orlrhsz +#define OCIRefIsEqual orlrequ +#define OCIRefIsNull orlrnul +#define OCIRefToHex orlr2h +#define OCIString orlvstr +#define OCIStringAllocSize orlvasz +#define OCIStringAssign orlvass +#define OCIStringAssignText orlvats +#define OCIStringPtr orlvgsp +#define OCIStringResize orlvrsz +#define OCIStringSize orlvgsz +#define OCITable orltbl +#define OCITableDelete orltdel +#define OCITableExists orltexi +#define OCITableFirst orltfst +#define OCITableLast orltlst +#define OCITableNext orltnxt +#define OCITablePrev orltprv +#define OCITableSize orltsiz +#define OCITime orldtm +#define OCITimeHH orldtmhh +#define OCITimeMI orldtmmm +#define OCITimeSS orldtmss +#define OCI_LOBMODE_READONLY ORLBMORO +#define OCI_LOBMODE_READWRITE ORLBMORW + +#endif /* SLSHORTNAME */ + +/*****************************************************************************/ +/* NUMBER/FLOAT/DECIMAL TYPE */ +/*****************************************************************************/ + +#define OCI_NUMBER_SIZE 22 +struct OCINumber +{ + ub1 OCINumberPart[OCI_NUMBER_SIZE]; +}; +typedef struct OCINumber OCINumber; + +/* + * OCINumber - OCI Number mapping in c + * + * The OTS types: NUMBER, NUMERIC, INT, SHORTINT, REAL, DOUBLE PRECISION, + * FLOAT and DECIMAL are represented by OCINumber. + * The contents of OCINumber is opaque to clients. + * + * For binding variables of type OCINumber in OCI calls (OCIBindByName(), + * OCIBindByPos(), and OCIDefineByPos()) use the type code SQLT_VNU. + */ + +/* + EXAMPLE + + The following example shows how to manipulate an attribute of type + oracle number. + + struct person + { + OCINumber sal; + }; + typedef struct person person; + + OCIError *err; + person* joe; + person* tom; + person* debbie; + OCINumber *joesal; + OCINumber *tomsal; + OCINumber *debsal; + sword status; + int inum; + double dnum; + OCINumber ornum; + char buffer[21]; + ub4 buflen; + sword result; + + /o See oci.h for an example of how to initialize OCIError. + o For this example, assume the OCIEnv and OCIError has been + o initialized. + o/ + + /o Pin joe, tom and debbie person objects in the object cache. See ori.h + o for an example on pinning objects. For this example, assume that + o joe, tom and debbie are pointing to pinned objects. + o/ + joesal = &joe->sal; + tomsal = &tom->sal; + debsal = &debbie->sal; + + /o initialize joe's salary to be $12,000 o/ + inum = 12000; + status = OCINumberFromInt(err, &inum, sizeof(inum), OCI_NUMBER_SIGNED, + joesal); + if (status != OCI_SUCCESS) + /o goto to handle error from OCINumberFromInt o/; + + /o initialize tom's salary to be same as joe o/ + OCINumberAssign(err, joesal, tomsal); + + /o initialize debbie's salary to be 20% more than joe's o/ + dnum = 1.2; + status = OCINumberFromReal(err, &dnum, sizeof(double), &ornum); + if (status != OCI_SUCCESS) + /o goto to handle error from OCINumberFromReal o/; + status = OCINumberMul(err, joesal, &ornum, debsal); + if (status != OCI_SUCCESS) /o goto to handle error from OCINumberMul o/; + + /o give tom a 50% raise o/ + dnum = 1.5; + status = OCINumberFromReal(err, &dnum, sizeof(double), &ornum); + if (status != OCI_SUCCESS) + /o goto to handle error from OCINumberFromReal o/; + status = OCINumberMul(err, tomsal, &ornum, tomsal); + if (status != OCI_SUCCESS) /o goto to handle error from OCINumberMul o/; + + /o double joe's salary o/ + status = OCINumberAdd(err, joesal, joesal, joesal); + if (status != OCI_SUCCESS) /o goto to handle error from OCINumberAdd o/; + + /o get joe's salary in integer o/ + status = OCINumberToInt(err, joesal, sizeof(inum), OCI_NUMBER_SIGNED, + &inum); + if (status != OCI_SUCCESS)/o goto to handle error from OCINumberToInt o/; + /o inum is set to 24000 o/ + + /o get debbie's salary in double o/ + status = OCINumberToReal(err, debsal, sizeof(dnum), &dnum); + if (status != OCI_SUCCESS)/o goto to handle error from OCINumberToReal o/; + /o dnum is set to 14400 o/ + + /o print tom's salary as DEM0001`8000.00 o/ + buflen = sizeof(buffer); + status = OCINumberToText(err, tomsal, "C0999G9999D99", 13, + "NLS_NUMERIC_CHARACTERS='.`' NLS_ISO_CURRENCY='Germany'", 54, + &buflen, buffer); + if (status != OCI_SUCCESS)/o goto to handle error from OCINumberToText o/; + printf("tom's salary = %s\n", buffer); + + /o compare joe and tom's salary o/ + status = OCINumberCmp(err, joesal, tomsal, &result); + if (status != OCI_SUCCESS) /o goto to handle error from OCINumberCmp o/; + /o result is positive o/ + + /o read debbie's new salary from string o/ + status = OCINumberFromText(err, "48`000.00", 9, "99G999D99", 9, + "NLS_NUMERIC_CHARACTERS='.`'", 27, debsal); + if (status != OCI_SUCCESS) + /o goto to handle error from OCINumberFromText o/; + /o debbie's salary is now 48000.00 o/ + +*/ + +/*----------------------------- OCINumberInc --------------------------------*/ + +sword OCINumberInc( OCIError *err, OCINumber *number ); +/* + NAME: OCINumberInc - OCINumber INCrement numbers + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + number (IN/OUT) a positive Oracle number to be incremented + DESCRIPTION: + Increment Oracle number in place. It is assumed that the input is + an integer between 0 and 100^21-2. If the is input too large, it will + be treated as 0 - the result will be an Oracle number 1. If the input + is not a positive integer, the result will be unpredictable. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + any of the number arguments is null + */ + +/*----------------------------- OCINumberDec --------------------------------*/ + +sword OCINumberDec( OCIError *err, OCINumber *number ); +/* + NAME: OCINumberDec - OCINumber DECrement numbers + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + number (IN/OUT) - a positive Oracle number to be decremented + DESCRIPTION: + Decrement Oracle number in place. It is assumed that the input is an + integer between 1 and 100^21-2. If the input is too large, it will be + treated as 1 - the result will be an Oracle number 0. If the input is + not a positive integer, the result will be unpredictable. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + any of the number arguments is null + */ + +/*-------------------------- OCINumberSetZero -------------------------------*/ + +void OCINumberSetZero( OCIError *err, OCINumber *num ); +/* + NAME: OCINumberSetZero - OCINumber Set number to Zero value + PARAMETERS: + err (IN/OUT) - pointer to OCI error handle + num (OUT) - set to zero value + DESCRIPTION: + Initialize the given number to value 0. + */ + +/*--------------------------- OCINumberSetPi --------------------------------*/ + +void OCINumberSetPi( OCIError *err, OCINumber *num ); +/* + NAME: OCINumberSetPi - OCINumber Set number to Pi + err (IN/OUT) - pointer to OCI error handle + num (OUT) - set to zero value + DESCRIPTION: + Initialize the given number to value Pi. + */ + +/*----------------------------- OCINumberAdd --------------------------------*/ + +sword OCINumberAdd( OCIError *err, const OCINumber *number1, + const OCINumber *number2, OCINumber *result ); +/* + NAME: OCINumberAdd - OCINumber ADD numbers + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + number1, number2 (IN) - numbers to be added + result (OUT) - result of adding 'number1' with 'number2' + DESCRIPTION: + Add 'number1' with 'number2' and return result in 'result'. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + any of the number arguments is null + */ + +/*----------------------------- OCINumberSub --------------------------------*/ + +sword OCINumberSub( OCIError *err, const OCINumber *number1, + const OCINumber *number2, OCINumber *result ); +/* + NAME: OCINumberSub - OCINumber SUBtract numbers + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + number1, number2 (IN) - 'number2' subtracted from 'number1' + result (OUT) - subtraction result + DESCRIPTION: + Subtract 'number2' from 'number1' and return result in 'result'. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + any of the number arguments is null + */ + +/*----------------------------- OCINumberMul --------------------------------*/ + +sword OCINumberMul( OCIError *err, const OCINumber *number1, + const OCINumber *number2, OCINumber *result ); +/* + NAME: OCINumberMul - OCINumber MULtiply numbers + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + number1, number2 (IN) - numbers to be multiplied + result (OUT) - multiplication result + DESCRIPTION: + Multiply 'number1' with 'number2' and return result in 'result'. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + any of the number arguments is null + */ + +/*----------------------------- OCINumberDiv --------------------------------*/ + +sword OCINumberDiv( OCIError *err, const OCINumber *number1, + const OCINumber *number2, OCINumber *result ); +/* + NAME: OCINumberDiv - OCINumber DIVide numbers + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + number1 (IN) - pointer to the numerator + number2 (IN) - pointer to the denominator + result (OUT) - division result + DESCRIPTION: + Divide 'number1' by 'number2' and return result in 'result'. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + any of the number arguments is null + underflow errorr + overflow errorr + divide by zero errorr + */ + +/*----------------------------- OCINumberMod --------------------------------*/ + +sword OCINumberMod( OCIError *err, const OCINumber *number1, + const OCINumber *number2, OCINumber *result ); +/* + NAME: OCINumberMod - OCINumber MODulous + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + number1 (IN) - pointer to the numerator + number2 (IN) - pointer to the denominator + result (OUT) - remainder of the result + DESCRIPTION: + Finds the remainder of the division of two Oracle numbers. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + any of the number arguments is null + divide by zero errorr + */ + +/*------------------------ OCINumberIntPower --------------------------------*/ + +sword OCINumberIntPower( OCIError *err, const OCINumber *base, + const sword exp, OCINumber *result ); +/* + NAME: OCINumberIntPower - OCINumber takes an arbitary base to an arbitary + integer PoWeR + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + base (IN) - base of the exponentiation + exp (IN) - exponent to which the base is to be raised + result (OUT) - output of exponentiation + DESCRIPTION: + Takes an arbitary base to an arbitary integer power. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + any of the number arguments is null + */ + +/*-------------------------- OCINumberShift ---------------------------------*/ + +sword OCINumberShift( OCIError *err, const OCINumber *number, + const sword nDig, OCINumber *result ); +/* + NAME: OCINumberShift - OCINumber multiplies by a power of 10. + + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + number (IN) - Oracle Number to be shifted. + nDig (IN) - number of decimal places to shift. + result (OUT) - shift result. + DESCRIPTION: + Multiplies number by 10^NDig and sets product to the result. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + any of the number arguments is null + */ + +/*----------------------------- OCINumberNeg --------------------------------*/ + +sword OCINumberNeg( OCIError *err, const OCINumber *number, + OCINumber *result ); +/* + NAME: OCINumberNeg - OCINumber NEGate number + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + number (IN) - number to be negated + result (OUT) - will contain negated value of 'number' + DESCRIPTION: + Negates an Oracle number. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + any of the number arguments is null + */ + +/*------------------------- OCINumberToText ---------------------------------*/ + +sword OCINumberToText( OCIError *err, const OCINumber *number, + const oratext *fmt, ub4 fmt_length, + const oratext *nls_params, ub4 nls_p_length, + ub4 *buf_size, oratext *buf ); +/* + NAME: OCINumberToText - OCINumber convert number TO String + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + number (IN) - Oracle number to be converted + fmt (IN) - conversion format + fmt_length (IN) - length of the 'fmt' parameter + nls_params (IN) - nls format specification, if null string + i.e. (oratext *)0, then the default parameters for the + session is used + nls_p_length (IN) - length of the 'nls_params' parameter + buf_size (IN/OUT) - size of the buffer must be passed as input by + the caller, this function will return the length of the + resulting string in bytes via this parameter. The length + does not include the terminating null ('\0'). + buf (OUT) - buffer into which the converted string is placed. The + resulting string is null terminated. + DESCRIPTION: + Converts the given number to a character string + according to the specified format. Refer to "TO_NUMBER" conversion + function described in "Oracle SQL Language Reference Manual" for a + description of format and NLS parameters. + The converted number string is stored in the buffer 'buf', up to + a max of '*buf_size' bytes. Length of the resulting string is + returned via 'buf_size'. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + 'number' or 'buf' is null + buffer too small + invalid format + invalid nls format + number to text translation for the given format causes overflow + */ + +/*-------------------------- OCINumberFromText ------------------------------*/ + +sword OCINumberFromText( OCIError *err, const oratext *str, + ub4 str_length, const oratext *fmt, ub4 fmt_length, + const oratext *nls_params, ub4 nls_p_length, + OCINumber *number ); +/* + NAME: OCINumberFromText - OCINumber convert String TO Number + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + str (IN) - input string to be converted to Oracle number + str_length (IN) - size of the input string + fmt (IN) - conversion format + fmt_length (IN) - length of the 'fmt' parameter + nls_params (IN) - nls format specification, if null string + i.e. (oratext *)0, then the default parameters for the + session is used + nls_p_length (IN) - length of the 'nls_params' parameter + number (OUT) - given string converted to number + DESCRIPTION: + Converts the given string to a number + according to the specified format. Refer to "TO_NUMBER" conversion + function described in "Oracle SQL Language Reference Manual" for a + description of format and NLS parameters. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + 'number' or 'str' is null + 'str_length' is 0 + invalid format + invalid nls format + invalid input string + */ + +/*-------------------------- OCINumberToInt ---------------------------------*/ + +#define OCI_NUMBER_UNSIGNED 0 /* Unsigned type -- ubX */ +#define OCI_NUMBER_SIGNED 2 /* Signed type -- sbX */ + +sword OCINumberToInt( OCIError *err, const OCINumber *number, + uword rsl_length, uword rsl_flag, void *rsl ); +/* + NAME: OCINumberToInt - OCINumber convert number TO Integer + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + number (IN) - number to be converted + rsl_length (IN) - size of the desired result + rsl_s_flag (IN) - flag denoting the desired sign of the output; valid + values are OCI_NUMBER_UNSIGNED, OCI_NUMBER_SIGNED + rsl (OUT) - pointer to space for the result + DESCRIPTION: + Native type conversion function. + Converts the given Oracle number into an xbx (e.g. ub2, ub4, sb2 etc.) + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + 'number' or 'rsl' is null + integer value of 'number' is too big -- overflow + integer value of 'number' is too small -- underflow + invalid sign flag value ('rsl_s_flag') + */ + +/*--------------------------- OCINumberFromInt ------------------------------*/ + +sword OCINumberFromInt( OCIError *err, const void *inum, uword inum_length, + uword inum_s_flag, OCINumber *number ); +/* + NAME: OCINumberFromInt - OCINumber convert Integer TO Number + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + inum (IN) - pointer to the integer to be converted + inum_length (IN) - size of the integer + inum_s_flag (IN) - flag that designates the sign of the integer; valid + values are OCI_NUMBER_UNSIGNED, OCI_NUMBER_SIGNED + number (OUT) - given integer converted to Oracle number + DESCRIPTION: + Native type conversion function. Converts any Oracle standard + machine-native integer type (xbx) to an Oracle number. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + 'number' or 'inum' is null + integer too BIG -- the number is too large to fit into an Oracle + number + invalid sign flag value ('inum_s_flag') + */ + +/*------------------------- OCINumberToReal ---------------------------------*/ + +sword OCINumberToReal( OCIError *err, const OCINumber *number, + uword rsl_length, void *rsl ); +/* + NAME: OCINumberToReal - OCINumber convert number TO Real + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + number (IN) - number to be converted + rsl_length (IN) - is the size of the desired result, + sizeof( float | double | long double) + rsl (OUT) - pointer to space for storing the result + DESCRIPTION: + Native type conversion function. Converts an Oracle number into a + machine-native real type. This function only converts numbers up to + LDBL_DIG, DBL_DIG, or FLT_DIG digits of precision and removes + trailing zeroes. The above constants are defined in float.h + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + 'number' or 'rsl' is null + 'rsl_length' is 0 + */ + +/*------------------------- OCINumberToRealArray ----------------------------*/ + +sword OCINumberToRealArray( OCIError *err, const OCINumber **number, + uword elems, uword rsl_length, void *rsl ); +/* + NAME: OCINumberToRealArray - OCINumber convert array of numbers TO Real + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + number (IN) - Pointer to array of number to be converted + elems (IN) - Upper bound of number array + rsl_length (IN) - is the size of the desired result, + sizeof( float | double | long double) + rsl (OUT) - pointer to array of space for storing the result + DESCRIPTION: + Native type conversion function. Converts an Oracle number into a + machine-native real type. This function only converts numbers up to + LDBL_DIG, DBL_DIG, or FLT_DIG digits of precision and removes + trailing zeroes. The above constants are defined in float.h + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + 'number' or 'rsl' is null + 'rsl_length' is 0 + */ + +/*-------------------------- OCINumberFromReal ------------------------------*/ + +sword OCINumberFromReal( OCIError *err, const void *rnum, + uword rnum_length, OCINumber *number ); +/* + NAME: OCINumberFromReal - OCINumber convert Real TO Number + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + rnum (IN) - pointer to the floating point number to be converted + rnum_length (IN) - size of the desired result, i.e. + sizeof({float | double | long double}) + number (OUT) - given float converted to Oracle number + DESCRIPTION: + Native type conversion function. Converts a machine-native floating + point type to an Oracle number. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + 'number' or 'rnum' is null + 'rnum_length' is 0 + */ + +/*----------------------------- OCINumberCmp --------------------------------*/ + +sword OCINumberCmp( OCIError *err, const OCINumber *number1, + const OCINumber *number2, sword *result ); +/* + NAME: OCINumberCmp - OCINumber CoMPare numbers + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + number1, number2 (IN) - numbers to be compared + result (OUT) - 0 if equal, negative if number1 < number2, + positive if number1 > number2 + DESCRIPTION: + The function OCINumberCmp compares two numbers. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + 'number1' or 'number2' or 'result' is null + */ + +/*---------------------------- OCINumberSign --------------------------------*/ + +sword OCINumberSign( OCIError *err, const OCINumber *number, + sword *result ); +/* + NAME: OCINumberSign - OCINumber obtains SiGN of an Oracle number + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + number (IN) - number whose sign is returned + result (OUT) - 0 if number == 0, -1 if number < 0, + 1 if number > 0 + DESCRIPTION: + Obtains sign of an Oracle number + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + 'number' or 'result' is null + */ + +/*---------------------------- OCINumberIsZero ------------------------------*/ + +sword OCINumberIsZero( OCIError *err, const OCINumber *number, + boolean *result ); +/* + NAME: OCINumberIsZero - OCINumber comparison with ZERo + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + number (IN) - numbers to be compared + result (OUT) - set to TRUE if equal to zero else FALSE + DESCRIPTION: + Test if the given number is equal to zero. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + 'number' or 'result' is null + */ + +/*---------------------------- OCINumberIsInt -------------------------------*/ + +sword OCINumberIsInt( OCIError *err, const OCINumber *number, + boolean *result ); +/* + NAME: OCINumberIsInt - OCINumber Is Integer value. + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + number (IN) - number to be tested + result (OUT) - set to TRUE if integer value else FALSE + DESCRIPTION: + Test if the given number is an integer value. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + 'number' or 'result' is null + */ + +/*-------------------------- OCINumberAssign --------------------------------*/ + +sword OCINumberAssign( OCIError *err, const OCINumber *from, + OCINumber *to ); +/* + NAME: OCINumberAssign - OCINumber ASsiGn number + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + from (IN) - number to be assigned + to (OUT) - number copied into + DESCRIPTION: + Assign number 'from' to 'to'. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + 'from' or 'to' is null + */ + +/*----------------------------- OCINumberAbs --------------------------------*/ + +sword OCINumberAbs( OCIError *err, const OCINumber *number, + OCINumber *result ); +/* + NAME: OCINumberAbs - OCINumber compute ABSolute value + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + number (IN) - input number + result (OUT) - output which will contain the absolue value of the + input number + DESCRIPTION: + Computes the absolute value of an Oracle number. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + any of the number arguments is null + */ + +/*---------------------------- OCINumberCeil --------------------------------*/ + +sword OCINumberCeil( OCIError *err, const OCINumber *number, + OCINumber *result ); +/* + NAME: OCINumberCeil - OCINumber compute the CEiL value of an Oracle number + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + number (IN) - input number + result (OUT) - output which will contain the ceil value of the + input number + DESCRIPTION: + Computes the ceil value of an Oracle number. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + any of the number arguments is null + */ + +/*--------------------------- OCINumberFloor --------------------------------*/ + +sword OCINumberFloor( OCIError *err, const OCINumber *number, + OCINumber *result ); +/* + NAME: OCINumberFloor - OCINumber compute the FLooR value of an Oracle number + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + number (IN) - input number + result (OUT) - output which will contain the floor value of the + input number + DESCRIPTION: + Computes the floor value of an Oracle number. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + any of the number arguments is null + */ + +/*----------------------------- OCINumberSqrt -------------------------------*/ + +sword OCINumberSqrt( OCIError *err, const OCINumber *number, + OCINumber *result ); +/* + NAME: OCINumberSqrt - OCINumber compute the SQuare Root of an Oracle number + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + number (IN) - input number + result (OUT) - output which will contain the square root of the + input number + DESCRIPTION: + Computes the square root of an Oracle number. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + any of the number arguments is null + 'number' is negative + */ + +/*--------------------------- OCINumberTrunc --------------------------------*/ + +sword OCINumberTrunc( OCIError *err, const OCINumber *number, + sword decplace, OCINumber *result ); +/* + NAME: OCINumberTrunc - OCINumber TRUncate an Oracle number at a + specified decimal place + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + number (IN) - input number + decplace (IN) - number of decimal digits to the right of the + decimal point to truncate at. Negative values are allowed. + result (OUT) - output of truncation + DESCRIPTION: + Truncate an Oracle number at a specified decimal place + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + any of the number arguments is null + */ + +/*----------------------------- OCINumberPower ------------------------------*/ + +sword OCINumberPower( OCIError *err, const OCINumber *base, + const OCINumber *number, OCINumber *result ); +/* + NAME: OCINumberPower - OCINumber takes an arbitary Base to an + arbitary Power + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + base (IN) - base of the exponentiation + number (IN) - exponent to which the base is to be raised + result (OUT) - output of exponentiation + DESCRIPTION: + Takes an arbitary base to an arbitary power. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + any of the number arguments is null + */ + +/*--------------------------- OCINumberRound --------------------------------*/ + +sword OCINumberRound( OCIError *err, const OCINumber *number, + sword decplace, OCINumber *result ); +/* + NAME: OCINumberRound - OCINumber ROUnds an Oracle number to a specified + decimal place + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + number (IN) - round this number and return result in 'result' + decplace (IN) - number of decimal digits to the right of the + decimal point to round to. Negative values are allowed. + result (OUT) - output of rounding + DESCRIPTION: + Rounds an Oracle number to a specified decimal place + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + any of the number arguments is null + */ + +/*--------------------------- OCINumberPrec ---------------------------------*/ + +sword OCINumberPrec( OCIError *err, const OCINumber *number, + sword nDigs, OCINumber *result ); +/* + NAME: OCINumberPrec - Rounds an Oracle number to a specified number of + decimal digits. + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + number (IN) - number for which to set precision. + nDig (IN) - number of decimal digits desired in the result. + result (OUT) - result. + DESCRIPTION: + Performs a floating point round with respect to the number + of digits. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + any of the number arguments is null + */ + +/*----------------------------- OCINumberSin --------------------------------*/ + +sword OCINumberSin( OCIError *err, const OCINumber *number, + OCINumber *result ); +/* + NAME: OCINumberSin - OCINumber takes the SINe of an Oracle number + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + number (IN) - argument of the sine in radians + result (OUT) - result of the sine + DESCRIPTION: + Takes the sine in radians of an Oracle number. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + any of the number arguments is null + */ + +/*-------------------------- OCINumberArcSin --------------------------------*/ + +sword OCINumberArcSin( OCIError *err, const OCINumber *number, + OCINumber *result ); +/* + NAME: OCINumberArcSin - OCINumber takes the Arc SINe of an Oracle number + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + number (IN) - argument of the arc sine + result (OUT) - result of the arc sine in radians + DESCRIPTION: + Takes the arc sine in radians of an Oracle number. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + any of the number arguments is null + 'number' is < -1 or 'number' is > 1. + */ + +/*-------------------------- OCINumberHypSin --------------------------------*/ + +sword OCINumberHypSin( OCIError *err, const OCINumber *number, + OCINumber *result ); +/* + NAME: OCINumberHypSin - OCINumber takes the SiNe Hyperbolic of an + Oracle number + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + number (IN) - argument of the sine hyperbolic + result (OUT) - result of the sine hyperbolic + DESCRIPTION: + Takes the hyperbolic sine of an Oracle number. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + any of the number arguments is null + NOTES: + An Oracle number overflow causes an unpredictable result value. + */ + +/*----------------------------- OCINumberCos --------------------------------*/ + +sword OCINumberCos( OCIError *err, const OCINumber *number, + OCINumber *result ); +/* + NAME: OCINumberCos - OCINumber takes the COSine of an Oracle number + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + number (IN) - argument of the cosine in radians + result (OUT) - result of the cosine + DESCRIPTION: + Takes the cosine in radians of an Oracle number. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + any of the number arguments is null + */ + +/*-------------------------- OCINumberArcCos --------------------------------*/ + +sword OCINumberArcCos( OCIError *err, const OCINumber *number, + OCINumber *result ); +/* + NAME: OCINumberArcCos - OCINumber takes the Arc COSine of an Oracle number + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + number (IN) - argument of the arc cosine + result (OUT) - result of the arc cosine in radians + DESCRIPTION: + Takes the arc cosine in radians of an Oracle number. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + any of the number arguments is null + 'number' is < -1 or 'number' is > 1. + */ + +/*-------------------------- OCINumberHypCos --------------------------------*/ + +sword OCINumberHypCos( OCIError *err, const OCINumber *number, + OCINumber *result ); +/* + NAME: OCINumberHypCos - OCINumber takes the CoSine Hyperbolic of an + Oracle number + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + number (IN) - argument of the cosine hyperbolic + result (OUT) - result of the cosine hyperbolic + DESCRIPTION: + Takes the hyperbolic cosine of an Oracle number. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + any of the number arguments is null + NOTES: + An Oracle number overflow causes an unpredictable result value. + */ + +/*----------------------------- OCINumberTan --------------------------------*/ + +sword OCINumberTan( OCIError *err, const OCINumber *number, + OCINumber *result ); +/* + NAME: OCINumberTan - OCINumber takes the TANgent of an Oracle number + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + number (IN) - argument of the tangent in radians + result (OUT) - result of the tangent + DESCRIPTION: + Takes the tangent in radians of an Oracle number. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + any of the number arguments is null + */ + +/*-------------------------- OCINumberArcTan --------------------------------*/ + +sword OCINumberArcTan( OCIError *err, const OCINumber *number, + OCINumber *result ); +/* + NAME: OCINumberArcTan - OCINumber takes the Arc TANgent of an Oracle number + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + number (IN) - argument of the arc tangent + result (OUT) - result of the arc tangent in radians + DESCRIPTION: + Takes the arc tangent in radians of an Oracle number. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + any of the number arguments is null + */ + +/*------------------------ OCINumberArcTan2 ---------------------------------*/ + +sword OCINumberArcTan2( OCIError *err, const OCINumber *number1, + const OCINumber *number2, OCINumber *result ); +/* + NAME: OCINumberArcTan2 - OCINumber takes the ATan2 of 2 Oracle numbers + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + number1 (IN) - first argument of atan2(y,x) function which + corresponds to 'y' parameter in the function + number2 (IN) - second argument of atan2(y,x) function which + corresponds to 'x' parameter in the function + result (OUT) - result of the atan2() in radians + DESCRIPTION: + Takes the atan2(number1, number2). + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + any of the number arguments is null + 'number2' is 0 + */ + +/*----------------------------- OCINumberHypTan -----------------------------*/ + +sword OCINumberHypTan( OCIError *err, const OCINumber *number, + OCINumber *result ); +/* + NAME: OCINumberHypTan - OCINumber takes the TaNgent Hyperbolic of an Oracle + number + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + number (IN) - argument of the tangent hyperbolic + result (OUT) - result of the tangent hyperbolic + DESCRIPTION: + Takes the hyperbolic tangent of an Oracle number. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + any of the number arguments is null + NOTES: + An Oracle number overflow causes an unpredictable result value. + */ + +/*--------------------------- OCINumberExp ----------------------------------*/ + +sword OCINumberExp( OCIError *err, const OCINumber *number, + OCINumber *result ); +/* + NAME: OCINumberExp - OCINumber EXPonential + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + number (IN) - e raised to this Oracle number power + result (OUT) - output of exponentiation + DESCRIPTION: + Raises e to the specified Oracle number power + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + any of the number arguments is null + */ + +/*----------------------------- OCINumberLn ---------------------------------*/ + +sword OCINumberLn( OCIError *err, const OCINumber *number, + OCINumber *result ); +/* + NAME: OCINumberLn - OCINumber Logarithm Natural + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + number (IN) - logarithm of this number is computed + result (OUT) - logarithm result + DESCRIPTION: + Takes the logarithm of the given Oracle number with respect + to the given base. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + any of the number arguments is null + 'number' is <= 0 + */ + +/*----------------------------- OCINumberLog --------------------------------*/ + +sword OCINumberLog( OCIError *err, const OCINumber *base, + const OCINumber *number, OCINumber *result ); +/* + NAME: OCINumberLog - OCINumber LOGarithm any base + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + base (IN) - base of the logarithm + number (IN) - opearnd + result (OUT) - logarithm result + DESCRIPTION: + Takes the logarithm with the specified base of an Oracle number. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + any of the number arguments is null + 'number' is <= 0 + 'base' is <= 0 + */ + +/*****************************************************************************/ +/* ORACLE DATE TYPE */ +/*****************************************************************************/ + +struct OCITime +{ + ub1 OCITimeHH; /* hours; range is 0 <= hours <=23 */ + ub1 OCITimeMI; /* minutes; range is 0 <= minutes <= 59 */ + ub1 OCITimeSS; /* seconds; range is 0 <= seconds <= 59 */ +}; +typedef struct OCITime OCITime; + +/* + * OCITime - OCI TiMe portion of date + * + * This structure should be treated as an opaque structure as the format + * of this structure may change. Use OCIDateGetTime/OCIDateSetTime + * to manipulate time portion of OCIDate. + */ + +struct OCIDate +{ + sb2 OCIDateYYYY; /* gregorian year; range is -4712 <= year <= 9999 */ + ub1 OCIDateMM; /* month; range is 1 <= month < 12 */ + ub1 OCIDateDD; /* day; range is 1 <= day <= 31 */ + OCITime OCIDateTime; /* time */ +}; +typedef struct OCIDate OCIDate; + +/* + * OCIDate - OCI oracle Date representation in C + * + * OCIDate represents the C mapping of Oracle date. + * + * This structure should be treated as an opaque structure as the format + * of this structure may change. Use OCIDateGetDate/OCIDateSetDate + * to access/initialize OCIDate. + * + * For binding variables of type OCIDate in OCI calls (OCIBindByName(), + * OCIBindByPos(), and OCIDefineByPos()) use the type code SQLT_ODT. + */ + +/* + EXAMPLE + + The following example shows how to manipulate an attribute of type + oracle date. + + #define FMT "Month dd, YYYY, HH:MI A.M." + #define LANG "American" + + struct person + { + OCIDate start_date; + }; + typedef struct person person; + + OCIError *err; + person *joe; + sword status; /o error status o/ + + /o See oci.h for an example of how to initialize OCIError. + o For this example, assume the OCIEnv and OCIError has been + o initialized. + o/ + + /o Pin joe person object in the object cache. See ori.h + o for an example on pinning objects. For this example, assume that + o joe is pointing to the pinned object. + o/ + + /o set the start date of joe o/ + OCIDateSetTime(&joe->start_date, 8, 0, 0); + OCIDateSetDate(&joe->start_date, 1990, 10, 5); + + /o check if the date is valid o/ + uword invalid; + if (OCIDateCheck(err, &joe->start_date, &invalid) != OCI_SUCCESS) + /o error handling code o/ + if (invalid) + /o error handling code o/ + + /o convert date for display purposes o/ + char str[100]; + ub4 strlen = sizeof(str); + if (OCIDateToText(err, &joe->start_date, FMT, sizeof(FMT)-1, LANG, + sizeof(LANG)-1, &strlen, str) != OCI_SUCCESS) + /o error handling code o/ + + */ + +/*--------------------------- OCIDateGetTime --------------------------------*/ +/* void OCIDateGetTime(/o_ const OCIDate *date, ub1 *hour, ub1 *min, + ub1 *sec _o/); */ +#define OCIDateGetTime(date, hour, min, sec) \ + { \ + *hour = (date)->OCIDateTime.OCITimeHH; \ + *min = (date)->OCIDateTime.OCITimeMI; \ + *sec = (date)->OCIDateTime.OCITimeSS; \ + } +/* + NAME: OCIDateGetTime - OCIDate Get Time portion of date + PARAMETERS: + date (IN) - Oracle date whose time data is retrieved + hour (OUT) - hour value returned + min (OUT) - minute value returned + sec (OUT) - second value returned + DESCRIPTION: + Return time inforamtion stored in the given date. The time + information returned is: hour, minute and seconds. + RETURNS: + NONE + */ + +/*--------------------------- OCIDateGetDate --------------------------------*/ +/* void OCIDateGetDate(/o_ const OCIDate *date, sb2 *year, ub1 *month, + ub1 *day _o/); */ +#define OCIDateGetDate(date, year, month, day) \ + { \ + *year = (date)->OCIDateYYYY; \ + *month = (date)->OCIDateMM; \ + *day = (date)->OCIDateDD; \ + } +/* + NAME: OCIDateGetDate - OCIDate Get Date (year, month, day) portion of date + PARAMETERS: + date (IN) - Oracle date whose year, month, day data is retrieved + year (OUT) - year value returned + month (OUT) - month value returned + day (OUT) - day value returned + DESCRIPTION: + Return year, month, day inforamtion stored in the given date. + RETURNS: + NONE + */ + +/*--------------------------- OCIDateSetTime --------------------------------*/ +/* void OCIDateSetTime(/o_ OCIDate *date, ub1 hour, ub1 min, + ub1 sec _o/); */ +#define OCIDateSetTime(date, hour, min, sec) \ + { \ + (date)->OCIDateTime.OCITimeHH = hour; \ + (date)->OCIDateTime.OCITimeMI = min; \ + (date)->OCIDateTime.OCITimeSS = sec; \ + } +/* + NAME: OCIDateSetTime - OCIDate Set Time portion of date + PARAMETERS: + date (OUT) - Oracle date whose time data is set + hour (IN) - hour value to be set + min (IN) - minute value to be set + sec (IN) - second value to be set + DESCRIPTION: + Set the date with the given time inforamtion. + RETURNS: + NONE + */ + +/*--------------------------- OCIDateSetDate --------------------------------*/ +/* void OCIDateSetDate(/o_ OCIDate *date, sb2 year, ub1 month, ub1 day _o/); */ +#define OCIDateSetDate(date, year, month, day) \ + { \ + (date)->OCIDateYYYY = year; \ + (date)->OCIDateMM = month; \ + (date)->OCIDateDD = day; \ + } +/* + NAME: OCIDateSetDate - OCIDate Set Date (year, month, day) portion of date + PARAMETERS: + date (IN) - Oracle date whose year, month, day data is set + year (OUT) - year value to be set + month (OUT) - month value to be set + day (OUT) - day value to be set + DESCRIPTION: + Set the date with the given year, month, day inforamtion. + RETURNS: + NONE + */ + +/*--------------------------- OCIDateAssign ---------------------------------*/ + +sword OCIDateAssign( OCIError *err, const OCIDate *from, + OCIDate *to ); +/* + NAME: OCIDateAssign - OCIDate Assignment + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + from (IN) - date to be assigned + to (OUT) - lhs of assignment + DESCRIPTION: + Performs date assignment. + RETURNS: + OCI_SUCCESS + */ + +/*--------------------------- OCIDateToText ---------------------------------*/ + +sword OCIDateToText( OCIError *err, const OCIDate *date, + const oratext *fmt, ub1 fmt_length, + const oratext *lang_name, ub4 lang_length, + ub4 *buf_size, oratext *buf ); +/* + NAME: OCIDateToText - OCIDate convert date TO String + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + date (IN) - Oracle date to be converted + fmt (IN) - conversion format, if null string pointer (oratext*)0, then + the date is converted to a character string in the + date format "DD-MON-YY". + fmt_length (IN) - length of the 'fmt' parameter + lang_name (IN) - specifies the language in which the names and + abbreviations of months and days are returned; + default language of session is used if 'lang_name' + is null i.e. (oratext *)0 + lang_length (IN) - length of the 'nls_params' parameter + buf_size (IN/OUT) - size of the buffer; size of the resulting string + is returned via this parameter + buf (OUT) - buffer into which the converted string is placed + DESCRIPTION: + Converts the given date to a string according to the specified format. + Refer to "TO_DATE" conversion function described in + "Oracle SQL Language Reference Manual" for a description of format + and NLS arguments. The converted null-terminated date string is + stored in the buffer 'buf'. + + An error is reported upon overflow, e.g. trying to convert a number + of value 10 using format '9' causes an overflow. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + buffer too small + invalid format + unknown language + overflow error + */ + +/*---------------------------- OCIDateFromText ------------------------------*/ + +sword OCIDateFromText( OCIError *err, const oratext *date_str, + ub4 d_str_length, const oratext *fmt, ub1 fmt_length, + const oratext *lang_name, ub4 lang_length, + OCIDate *date ); +/* + NAME: OCIDateFromText - OCIDate convert String TO Date + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + date_str (IN) - input string to be converted to Oracle date + d_str_length (IN) - size of the input string, if the length is -1 + then 'date_str' is treated as a null terminated string + fmt (IN) - conversion format; if 'fmt' is a null pointer, then + the string is expected to be in 'DD-MON-YY' format. + fmt_length (IN) - length of the 'fmt' parameter + lang_name (IN) - language in which the names and abbreviations of + days and months are specified, if null i.e. (oratext *)0, + the default language of session is used, + lang_length (IN) - length of the 'lang_name' parameter + date (OUT) - given string converted to date + DESCRIPTION: + Converts the given string to Oracle date + according to the specified format. Refer to "TO_DATE" conversion + function described in "Oracle SQL Language Reference Manual" for a + description of format. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + invalid format + unknown language + invalid input string + + */ + +/*----------------------------- OCIDateCompare ------------------------------*/ + +sword OCIDateCompare( OCIError *err, const OCIDate *date1, + const OCIDate *date2, sword *result ); +/* + NAME: OCIDateCompare - OCIDate CoMPare dates + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + date1, date2 (IN) - dates to be compared + result (OUT) - comparison result, 0 if equal, -1 if date1 < date2, + 1 if date1 > date2 + DESCRIPTION: + The function OCIDateCompare compares two dates. It returns -1 if date1 + is smaller than date2, 0 if they are equal, and 1 if date1 is greater + than date2. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + invalid date + + */ + +/*------------------------- OCIDateAddMonths --------------------------------*/ + +sword OCIDateAddMonths( OCIError *err, const OCIDate *date, sb4 num_months, + OCIDate *result ); +/* + NAME: OCIDateAddMonths - OCIDate ADd or subtract Months + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + date (IN) - 'num_months' added or subtracted from 'date' + num_months (IN) - number of months to be added or subtracted + (a negative value will be subtracted) + result (IN/OUT) - result of adding or subtracting to 'date' + DESCRIPTION: + The function OCIDateAddDays adds or subtracts num_months from the + date 'date'. + If the input 'date' is the last day of a month, then + appropriate adjustments are made to ensure that the output date is + also the last day of the month. For example, Feb. 28 + 1 month = + March 31, and November 30 - 3 months = August 31. Otherwise the + 'result' date has the same day component as 'date'. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + invalid date + + */ + +/*--------------------------- OCIDateAddDays --------------------------------*/ + +sword OCIDateAddDays( OCIError *err, const OCIDate *date, sb4 num_days, + OCIDate *result ); +/* + NAME: OCIDateAddDays - OCIDate ADd or subtract Days + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + date (IN) - 'num_days' added or subtracted from 'date' + num_days (IN) - number of days to be added or subtracted + (a negative value will be subtracted) + result (IN/OUT) - result of adding or subtracting to 'date' + DESCRIPTION: + The function OCIDateAddDays adds or subtracts num_days from the + date 'date'. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + invalid date + + */ + +/*--------------------------- OCIDateLastDay --------------------------------*/ + +sword OCIDateLastDay( OCIError *err, const OCIDate *date, + OCIDate *last_day ); +/* + NAME: OCIDateLastDay - OCIDate get date of the LaST day of the month + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + date (IN) - input date + last_day (OUT) - last day of the month in date 'date' + DESCRIPTION: + The function OCIDateLastDay returns the date of the last day of the + month in date 'date'. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + invalid date + + */ + +/*----------------------- OCIDateDaysBetween --------------------------------*/ + +sword OCIDateDaysBetween( OCIError *err, const OCIDate *date1, + const OCIDate *date2, sb4 *num_days ); +/* + NAME: OCIDateDaysBetween - OCIDate get number of days BeTWeen two dates + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + date1, date2 (IN) - input dates + num_days (OUT) - number of days between date1 and date2 + DESCRIPTION: + The function OCIDateDaysBetween returns the number of days between + date1 and date2. The time is ignored in this computation. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + invalid date + + */ + +/*------------------------ OCIDateZoneToZone --------------------------------*/ + +sword OCIDateZoneToZone( OCIError *err, const OCIDate *date1, + const oratext *zon1, + ub4 zon1_length, const oratext *zon2, + ub4 zon2_length, OCIDate *date2 ); +/* + NAME: OCIDateZoneToZone - OCIDate convert date from one Zone TO another Zone + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + date1 (IN) - date to be converted + zon1 (IN) - zone of input date + zon1_length (IN) - length in bytes of string 'zon1' + zon2 (IN) - zone to be converted to + zon2_length (IN) - length in bytes of string 'zon2' + date2 (OUT) - converted date (in 'zon2') + DESCRIPTION: + Converts date from one time zone to another. Given date 'date1' + in time zone 'zon1' returns date 'date2' in time zone 'zon2'. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + invlid date + invald input time zone + invald output time zone + + */ + +/*--------------------------- OCIDateNextDay --------------------------------*/ + +sword OCIDateNextDay( OCIError *err, const OCIDate *date, + const oratext *day_p, ub4 day_length, + OCIDate *next_day ); +/* + NAME: OCIDateNextDay - OCIDate get date of Next DaY + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + date (IN) - returned date should be later than this date + day (IN) - first day of week named by this is returned + day_length (IN) - length in bytes of string 'day' + next_day (OUT) - first day of the week named by 'day' later than 'date' + DESCRIPTION: + Returns the date of the first day of the + week named by 'day' that is later than date 'date'. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + invalid date + invalid day + + */ + +/*----------------------------- OCIDateCheck --------------------------------*/ + +/* Listing of error bits used by OCIDateCheck() */ +#define OCI_DATE_INVALID_DAY 0x1 /* Bad DAy */ +#define OCI_DATE_DAY_BELOW_VALID 0x2 /* Bad DAy Low/high bit (1=low)*/ +#define OCI_DATE_INVALID_MONTH 0x4 /* Bad MOnth */ +#define OCI_DATE_MONTH_BELOW_VALID 0x8 /* Bad MOnth Low/high bit (1=low)*/ +#define OCI_DATE_INVALID_YEAR 0x10 /* Bad YeaR */ +#define OCI_DATE_YEAR_BELOW_VALID 0x20 /* Bad YeaR Low/high bit (1=low)*/ +#define OCI_DATE_INVALID_HOUR 0x40 /* Bad HouR */ +#define OCI_DATE_HOUR_BELOW_VALID 0x80 /* Bad HouR Low/high bit (1=low)*/ +#define OCI_DATE_INVALID_MINUTE 0x100 /* Bad MiNute */ +#define OCI_DATE_MINUTE_BELOW_VALID 0x200 + /* Bad MiNute Low/high bit (1=low)*/ +#define OCI_DATE_INVALID_SECOND 0x400 /* Bad SeCond */ +#define OCI_DATE_SECOND_BELOW_VALID 0x800 + /* bad second Low/high bit (1=low)*/ +#define OCI_DATE_DAY_MISSING_FROM_1582 0x1000 + /* Day is one of those "missing" from 1582 */ +#define OCI_DATE_YEAR_ZERO 0x2000 /* Year may not equal zero */ +#define OCI_DATE_INVALID_FORMAT 0x8000 /* Bad date format input */ + +sword OCIDateCheck( OCIError *err, const OCIDate *date, uword *valid ); +/* + NAME: OCIDateCheck - OCIDate CHecK if the given date is valid + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + date (IN) - date to be checked + valid (OUT) - returns zero for a valid date, otherwise + the ORed combination of all error bits specified below: + + Macro name Bit number Error + ---------- ---------- ----- + OCI_DATE_INVALID_DAY 0x1 Bad day + OCI_DATE_DAY_BELOW_VALID 0x2 Bad DAy Low/high bit (1=low) + OCI_DATE_INVALID_MONTH 0x4 Bad MOnth + OCI_DATE_MONTH_BELOW_VALID 0x8 Bad MOnth Low/high bit (1=low) + OCI_DATE_INVALID_YEAR 0x10 Bad YeaR + OCI_DATE_YEAR_BELOW_VALID 0x20 Bad YeaR Low/high bit (1=low) + OCI_DATE_INVALID_HOUR 0x40 Bad HouR + OCI_DATE_HOUR_BELOW_VALID 0x80 Bad HouR Low/high bit (1=low) + OCI_DATE_INVALID_MINUTE 0x100 Bad MiNute + OCI_DATE_MINUTE_BELOW_VALID 0x200 Bad MiNute Low/high bit (1=low) + OCI_DATE_INVALID_SECOND 0x400 Bad SeCond + OCI_DATE_SECOND_BELOW_VALID 0x800 bad second Low/high bit (1=low) + OCI_DATE_DAY_MISSING_FROM_1582 0x1000 Day is one of those "missing" + from 1582 + OCI_DATE_YEAR_ZERO 0x2000 Year may not equal zero + OCI_DATE_INVALID_FORMAT 0x8000 Bad date format input + + So, for example, if the date passed in was 2/0/1990 25:61:10 in + (month/day/year hours:minutes:seconds format), the erroor returned + would be OCI_DATE_INVALID_DAY | OCI_DATE_DAY_BELOW_VALID | + OCI_DATE_INVALID_HOUR | OCI_DATE_INVALID_MINUTE + + DESCRIPTION: + Check if the given date is valid. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + 'date' and 'valid' pointers are NULL pointers + */ + +/*--------------------------- OCIDateSysDate --------------------------------*/ + +sword OCIDateSysDate( OCIError *err, OCIDate *sys_date ); +/* + NAME: OCIDateSysDate - OCIDate get current SYStem date and time + PARAMETERS: + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + sys_date (OUT) - current system date and time + DESCRIPTION: + Returns the current system date and time. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'err' is NULL. + OCI_ERROR if + + */ + +/*****************************************************************************/ +/* FIXED-LENGTH STRING - CHAR (N) */ +/*****************************************************************************/ + +/* + * An ADT attribute declared as "x CHAR(n)" is mapped to "OCIString *x;". + * The representation of OCIString * is shown below. + */ + +/*****************************************************************************/ +/* VARIABLE-LENGTH STRING */ +/*****************************************************************************/ + +/* + * The variable-length string is represented in C as a pointer to OCIString + * structure. The OCIString structure is opaque to the user. Functions are + * provided to allow the user to manipulate a variable-length string. + * + * A variable-length string can be declared as: + * + * OCIString *vstr; + * + * For binding variables of type OCIString* in OCI calls (OCIBindByName(), + * OCIBindByPos() and OCIDefineByPos()) use the external type code SQLT_VST. + */ +typedef struct OCIString OCIString; + +/*-------------------------- OCIStringAssign --------------------------------*/ + +sword OCIStringAssign( OCIEnv *env, OCIError *err, const OCIString *rhs, + OCIString **lhs ); +/* + NAME: OCIStringAssign - OCIString Assign String to String + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode. + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + rhs (IN) - RHS of the assignment, the type of rhs is also OCIString + lhs (IN/OUT) - LHS of the assignment + DESCRIPTION: + Assign 'rhs' string to 'lhs' string. The 'lhs' string may be + resized depending upon the size of the 'rhs'. The assigned string is + null-terminated. The 'length' field will not include the extra byte + needed for null termination. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is NULL. + OCI_ERROR if + out of space error + */ + +/*---------------------- OCIStringAssignText --------------------------------*/ + +sword OCIStringAssignText( OCIEnv *env, OCIError *err, const oratext *rhs, + ub4 rhs_len, OCIString **lhs ); +/* + NAME: OCIStringAssignText - OCIString Assign Text string to String + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode. + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + rhs (IN) - RHS of the assignment, the type of rhs is a text string + rhs_len (IN) - length of the 'rhs' string + lhs (IN/OUT) - LHS of the assignment + DESCRIPTION: + Assign 'rhs' string to 'lhs' string. The 'lhs' string may be + resized depending upon the size of the 'rhs'. The assigned string is + null-terminated. The 'length' field will not include the extra byte + needed for null termination. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is NULL. + OCI_ERROR if + out of space error + */ + +/*-------------------------- OCIStringResize --------------------------------*/ + +sword OCIStringResize( OCIEnv *env, OCIError *err, ub4 new_size, + OCIString **str ); +/* + NAME: OCIStringResize - OCIString ReSiZe string memory + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode. + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + new_size (IN) - new memory size of the string in bytes + str (IN/OUT) - allocated memory for the string is freed from the + OOCI heap + DESCRIPTION: + This function resizes the memory of the given variable-length string in + the object cache. The contents of the string are NOT preserved. + This function may allocate the string in a new memory region in + which case the original memory occupied by the given string will + be freed. If the input string is null (str == NULL), then this + function will allocate memory for the string. + + If the new_size is 0, then this function frees the memory occupied + by 'str' and a null pointer value is returned. + + NOTE: The caller must compute 'new_size' taking into account space + for the null character ('\0'). + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is NULL. + OCI_ERROR if + out of space error + */ + +/*---------------------------- OCIStringSize --------------------------------*/ + +ub4 OCIStringSize( OCIEnv *env, const OCIString *vs ); +/* + NAME: OCIStringSize - OCIString Get String siZe + PARAMETERS: + env(IN) - pointer to OCI environment handle + vs (IN) - string whose size is returned + DESCRIPTION: + Return the size of the given string. + RETURNS: + size of the string in bytes is returned + */ + +/*----------------------------- OCIStringPtr --------------------------------*/ + +oratext *OCIStringPtr( OCIEnv *env, const OCIString *vs ); +/* + NAME: OCIStringPtr - OCIString Get String Pointer + PARAMETERS: + env(IN) - pointer to OCI environment handle + vs (IN) - pointer to the text of this string is returned + DESCRIPTION: + Return the pointer to the text of the given string. + RETURNS: + pointer to the text of the string is returned + */ + +/*----------------------- OCIStringAllocSize --------------------------------*/ + +sword OCIStringAllocSize( OCIEnv *env, OCIError *err, const OCIString *vs, + ub4 *allocsize ); +/* + NAME: OCIStringAllocSize - OCIString get Allocated SiZe of string memory + in bytes + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode. + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + vs (IN) - string whose allocated size in bytes is returned + allocsize (OUT) - allocated size of string memory in bytes is returned + DESCRIPTION: + Return the allocated size of the string memory in bytes. The + allocated size is >= actual string size. + REQUIRES: + vs is a non-null pointer + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is NULL. + OCI_ERROR on error + */ + +/*****************************************************************************/ +/* VARIABLE-LENGTH RAW */ +/*****************************************************************************/ + +/* + * The variable-length raw is represented in C as a pointer to OCIRaw + * structure. The OCIRaw structure is opaque to the user. Functions are + * provided to allow the user to manipulate a variable-length raw. + * + * A variable-length raw can be declared as: + * + * OCIRaw *raw; + * + * For binding variables of type OCIRaw* in OCI calls (OCIBindByName(), + * OCIBindByPos() and OCIDefineByPos()) use the external type code SQLT_LVB. + */ +typedef struct OCIRaw OCIRaw; + +/*-------------------------- OCIRawAssignRaw --------------------------------*/ + +sword OCIRawAssignRaw( OCIEnv *env, OCIError *err, const OCIRaw *rhs, + OCIRaw **lhs ); +/* + NAME: OCIRawAssignRaw - OCIRaw Assign Raw (of type OCIRaw*) to + Raw (of type OCIRaw*) + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode. + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + rhs (IN) - RHS of the assignment, the type of rhs is also OCIRaw + lhs (IN/OUT) - LHS of the assignment + DESCRIPTION: + Assign 'rhs' raw to 'lhs' raw. The 'lhs' raw may be + resized depending upon the size of the 'rhs'. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is NULL. + OCI_ERROR if + out of space error + */ + +/*------------------------ OCIRawAssignBytes --------------------------------*/ + +sword OCIRawAssignBytes( OCIEnv *env, OCIError *err, const ub1 *rhs, + ub4 rhs_len, OCIRaw **lhs ); +/* + NAME: OCIRawAssignBytes - OCIRaw Assign raw Bytes (of type ub1*) to Raw + (of type OCIRaw*) + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode. + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + rhs (IN) - RHS of the assignment, the type of rhs is ub1 * + rhs_len (IN) - length of the 'rhs' raw + lhs (IN/OUT) - LHS of the assignment + DESCRIPTION: + Assign 'rhs' raw to 'lhs' raw. The 'lhs' raw may be + resized depending upon the size of the 'rhs'. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is NULL. + OCI_ERROR if + out of space error + */ + +/*---------------------------- OCIRawResize ---------------------------------*/ + +sword OCIRawResize( OCIEnv *env, OCIError *err, ub4 new_size, + OCIRaw **raw ); +/* + NAME: OCIRawResize - OCIRaw ReSiZe memory of variable-length raw + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode. + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + new_size (IN) - new size of the raw data in bytes + raw (IN) - variable-length raw pointer; the raw is + resized to 'new_size' + DESCRIPTION: + This function resizes the memory of the given variable-length raw in + the object cache. + The previous contents of the raw are NOT preserved. + This function may allocate the raw in a new memory region in + which case the original memory occupied by the given raw will + be freed. If the input raw is null (raw == NULL), then this + function will allocate memory for the raw data. + + If the new_size is 0, then this function frees the memory occupied + by 'raw' and a null pointer value is returned. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is NULL. + OCI_ERROR if + out of space error + */ + +/*------------------------------- OCIRawSize --------------------------------*/ + +ub4 OCIRawSize( OCIEnv * env, const OCIRaw *raw ); +/* + NAME: OCIRawSize - OCIRaw Get Raw siZe + PARAMETERS: + env (IN) - pointer to OCI environment handle + raw (INT) - raw whose size is returned + DESCRIPTION: + Return the size of the given raw. + RETURNS: + size of the raw in bytes is returned + */ + +/*--------------------------------- OCIRawPtr -------------------------------*/ +ub1 *OCIRawPtr( OCIEnv * env, const OCIRaw *raw ); +/* + NAME: OCIRawPtr - OCIRaw Get Raw data Pointer + PARAMETERS: + env (IN) - pointer to OCI environment handle + raw (IN) - pointer to the data of this raw is returned + DESCRIPTION: + Return the pointer to the data of the given raw. + RETURNS: + pointer to the data of the raw is returned + */ + +/*------------------------------ OCIRawAllocSize ----------------------------*/ + +sword OCIRawAllocSize( OCIEnv *env, OCIError *err, const OCIRaw *raw, + ub4 *allocsize ); +/* + NAME: OCIRawAllocSize - OCIRaw get Allocated SiZe of raw memory in bytes + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode. + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + raw (IN) - raw whose allocated size in bytes is returned + allocsize (OUT) - allocated size of raw memory in bytes is returned + DESCRIPTION: + Return the allocated size of the raw memory in bytes. The + allocated size is >= actual raw size. + REQUIRES: + raw is a non-null pointer + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is NULL. + OCI_ERROR upon error + */ + +/*****************************************************************************/ +/* OBJECT REFERENCE OPERATIONS */ +/*****************************************************************************/ + +/* + * See the definition of OCIRef in oro.h. + * + * For binding variables of type OCIRef* in OCI calls (OCIBindByName(), + * OCIBindByPos() and OCIDefineByPos()) use the code SQLT_REF. + * + */ + +/*---------------------------- OCIRefClear ----------------------------------*/ +void OCIRefClear( OCIEnv *env, OCIRef *ref ); +/* + NAME: OCIRefClear - OCIRef CLeaR or nullify a ref + PARAMETERS: + env (IN) - pointer to OCI environment handle + ref (IN/OUT) - ref to clear + DESCRIPTION: + Clear or nullify the given ref. A ref is considered to be a null ref + if it does not contain a valid OID (and thus doesn't point to an + object). Logically, a null ref is a dangling ref. + + Note that a null ref is still a valid SQL value and is not SQL-ly null. + It can be used as a valid non-null constant ref value for NOT NULL + column or attribute of a row in a table. + + If a null pointer value is passed as a ref, + then this function is a no-op. + */ + +/*--------------------------- OCIRefAssign ----------------------------------*/ +sword OCIRefAssign( OCIEnv *env, OCIError *err, const OCIRef *source, + OCIRef **target ); +/* + NAME: OCIRefAssign - OCIRef CoPY a ref to another + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode. + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + source (IN) - ref to copy from + target (IN/OUT) - ref to copy to + DESCRIPTION: + Copy 'source' ref to 'target' ref; both then reference the same + object. If the target ref pointer is null (i.e. *target == NULL) + then the copy function will allocate memory for the target ref + in OOCI heap prior to the copy. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is NULL. + OCI_ERROR if + 1) out of memory + */ + +/*-------------------------- OCIRefIsEqual ----------------------------------*/ +boolean OCIRefIsEqual( OCIEnv *env, const OCIRef *x, const OCIRef *y ); +/* + NAME: OCIRefIsEqual - OCIRef compare two refs for EQUality + PARAMETERS: + env (IN) - pointer to OCI environment handle + x (IN) - ref to compare + y (IN) - ref to compare + DESCRIPTION: + Compare the given refs for equality. + Two refs are equal if and only if: + - they are both referencing the same persistent object, or + - they are both referencing the same transient object. + + NOTE THAT TWO NULL REFS ARE CONSIDERED NOT EQUAL BY THIS FUNCTION. + RETURNS: + TRUE if the two refs are equal + FALSE if the two refs are not equal, or X is NULL, or Y is NULL + */ + +/*--------------------------- OCIRefIsNull ----------------------------------*/ +boolean OCIRefIsNull( OCIEnv *env, const OCIRef *ref ); +/* + NAME: OCIRefIsNull - OCIRef test if a ref is NULl + PARAMETERS: + env (IN) - pointer to OCI environment handle + ref (IN) - ref to test for null + DESCRIPTION: + Return TRUE if the given ref is null; otherwise, return FALSE. + A ref is null if and only if: + - it is supposed to be referencing a persistent object, but + its OID is null, or + - it is supposed to be referencing a transient object, but it is + currently not pointing to an object. + A ref is a dangling ref if the object that it points to does not + exist. + RETURNS: + TRUE if the given ref is NULL + FALSE if the given ref is not NULL + */ + +/*-------------------------- OCIRefHexSize ----------------------------------*/ +ub4 OCIRefHexSize( OCIEnv *env, const OCIRef *ref ); +/* + NAME: OCIRefHexSize - OCIRef Hexadecimal buffer SiZe in bytes + PARAMETERS: + env (IN) - pointer to OCI environment handle + ref (IN) - ref whose size in hexadecimal representation in bytes is + returned + DESCRIPTION: + Return the size of the buffer in bytes required for the hexadecimal + representation of the ref. A buffer of at-least this size must be + passed to ref-to-hex (OCIRefToHex) conversion function. + RETURNS: + size of hexadecimal representation of ref + */ + +/*-------------------------- OCIRefFromHex ---------------------------------*/ +sword OCIRefFromHex( OCIEnv *env, OCIError *err, const OCISvcCtx *svc, + const oratext *hex, ub4 length, OCIRef **ref ); +/* + NAME: + OCIRefFromHex - OCIRef convert a Hexadecimal string TO a Ref + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by + calling OCIErrorGet(). + svc (IN) - OCI service context handle; if the resulting ref is + initialized with this service context + hex (IN) - hexadecimal string (that was produced by 'OCIRefToHex()" + previously) to be convert into a ref + length (IN) - length of the hexadecimal string + ref (IN/OUT) - ref is initialized with the given value ('hex'). + If *ref is null, then space for the ref is allocated in the + object cache, otherwise the memory occupied by the given ref + is re-used. + DESCRIPTION: + Convert the given hexadecimal string into a ref. This function + ensures that the resulting ref is well formed. It does NOT ensure + that the object pointed to by the resulting ref exists or not. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is NULL. + OCI_ERROR if + */ + +/*--------------------------- OCIRefToHex -----------------------------------*/ +sword OCIRefToHex( OCIEnv *env, OCIError *err, const OCIRef *ref, + oratext *hex, ub4 *hex_length ); +/* + NAME: + OCIRefToHex - OCIRef convert ref to a Hexadecimal string + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by + calling OCIErrorGet(). + ref (IN) - ref to be converted into a hexadecimal string; if the + ref is a null ref (i.e. OCIRefIsNull(ref) == TRUE) then + a zero hex_length value is returned + hex (OUT) - buffer that is large enough to contain the resulting + hexadecimal string; the contents of the string is opaque + to the caller + hex_length (IN/OUT) - on input specifies the size of the 'hex' buffer, + on output specifies the actual size of the hexadecimal + string being returned in 'hex' + DESCRIPTION: + Convert the given ref into a hexadecimal string, and return the length + of the string. The resulting string is opaque to the caller. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is NULL. + OCI_ERROR if + the given buffer is not big enough to hold the resulting string + */ + + +/*****************************************************************************/ +/* COLLECTION FUNCTIONS */ +/*****************************************************************************/ + +/* + The generic collection is represented by the type 'OCIColl'. The following + operations OCIColl*() are provided on a generic collection: + - get current size of collection + - get upper bound of collection + - get pointer to an element given its index + - set element at given index (assign element) + - append an element + - trim the given number of elements from the end of the collection + - collection assignment + + The following iterator based scanning functions are also provided on a + generic collection. These functions make use of an iterator which is + defined to be of type OCIIter. + + - create an iterator for scanning collection + - destroy iterator + - reset iterator to the beginning of collection + - get pointer to current element pointed by iterator + - get pointer to next element + - get pointer to previous element + + The collections variable-length array (varray) and nested table + are sub-types of generic collection. This means that the OCIColl*() + functions can also be used to manipulate varray and nested table. + + The varray is represented by OCIArray type and nested table by OCITable. + Besides OCIColl*() functions no additional functions are provided for + manipulating varrays. The OCIColl*() functions are a complete set of + functions to manipulate varrays. + + Besides OCIColl*() functions, the following functions OCITable*() can be + used to manipulate nested table. The OCITable*() functions operate on + nested tables only and should not be used on a varray. + + - delete an element at index i. Note that the position + ordinals of the remaining elements of the table is not changed by the + delete operation. So delete creates "holes" in the table. + - check if an element exists at the given index i + - return the smallest value of i for which exists(i) is true + - return the largest value of i for which exists(i) is true + - return pointer to the smallest position j, greater than i, such that + OCITableExists(j) is true + - return pointer to the largest position j, less than i, such that + OCITableExists(j) is true + + For binding variables of type OCIColl* or OCITable* in OCI calls + (OCIBindByName(), OCIBindByPos() and OCIDefineByPos()) use the external + type code SQLT_NTY. + */ + +/* OCIColl - generic collection type */ +typedef struct OCIColl OCIColl; + +/* OCIArray - varray collection type */ +typedef OCIColl OCIArray; + +/* OCITable - nested table collection type */ +typedef OCIColl OCITable; + +/* OCIIter - collection iterator */ +typedef struct OCIIter OCIIter; + +/*----------------------------- OCICollSize ---------------------------------*/ + +sword OCICollSize( OCIEnv *env, OCIError *err, const OCIColl *coll, + sb4 *size ); +/* + NAME: OCICollSize - OCIColl return current SIZe of the given collection + PARAMETERS: + env(IN) - pointer to OCI environment handle + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + coll (IN) - collection whose number of elements is returned + size (OUT) - current number of elements in the collection + DESCRIPTION: + Returns the current number of elements in the given collection. + + For collections of type nested table wherein 'delete element' + operation is allowed, the count returned by OCICollSize() will + NOT be decremented upon deleting elements. For example: + + OCICollSize(...); + // assume 'size' returned is equal to 5 + OCITableDelete(...); // delete one element + OCICollSize(...); + // 'size' returned will still be 5 + + To get the count minus the deleted elements use OCITableSize(). + Continuing the above example, + + OCITableSize(...) + // 'size' returned will be equal to 4 + + Note, a trim operation (OCICollTrim) will decrement the count + by the number of trimmed elements. Continuing the above example, + + OCICollTrim(..,1..); // trim one element + OCICollSize(...); + // 'size' returned will be equal to 4 + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is NULL. + OCI_ERROR if + error during loading of collection into object cache + any of the input parameters is null + */ + +/*------------------------------ OCICollMax ---------------------------------*/ + +sb4 OCICollMax( OCIEnv *env, const OCIColl *coll ); +/* + NAME: OCICollMax - OCIColl return MAXimum size (upper-bound) of the + given collection (in number of elements) + PARAMETERS: + env(IN) - pointer to OCI environment handle + coll (IN) - collection whose upper-bound in number of elements + is returned + DESCRIPTION: + Returns the max number of elements that the given collection can hold. + A value 0 indicates that the collection has no upper-bound. + REQUIRES: + coll must point to a valid collection descriptor + RETURNS: + upper-bound of the given collection + */ + +/*-------------------------- OCICollGetElem ---------------------------------*/ + +sword OCICollGetElem( OCIEnv *env, OCIError *err, const OCIColl *coll, + sb4 index, boolean *exists, void **elem, + void **elemind ); +/* + NAME: OCICollGetElem - OCIColl GET pointer to the element at the given index + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode. + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + coll (IN) - pointer to the element in this collection is returned + index (IN) - index of the element whose pointer is returned + exists (OUT) - set to FALSE if element at the specified index does + not exist else TRUE + elem (OUT) - address of the desired element is returned + elemind (OUT) [optional] - address of the null indicator information + is returned; if (elemind == NULL) then the null indicator + information will NOT be returned + DESCRIPTION: + Get the address of the element at the given position. Optionally + this function also returns the address of the element's null indicator + information. + + The following table describes for each collection element type + what the corresponding element pointer type is. The element pointer + is returned via the 'elem' parameter of OCICollGetElem(). + + Element Type *elem is set to + ----------------------- --------------- + Oracle Number (OCINumber) OCINumber* + Date (OCIDate) OCIDate* + Variable-length string (OCIString*) OCIString** + Variable-length raw (OCIRaw*) OCIRaw** + object reference (OCIRef*) OCIRef** + lob locator (OCILobLocator*) OCILobLocator** + object type (e.g. person) person* + + The element pointer returned by OCICollGetElem() is in a form + such that it can not only be used to access the + element data but also is in a form that can be used as the target + (i.e left-hand-side) of an assignment statement. + + For example, assume the user is iterating over the elements of + a collection whose element type is object reference (OCIRef*). A call + to OCICollGetElem() returns pointer to a reference handle + (i.e. OCIRef**). After getting, the pointer to the collection + element, the user may wish to modify it by assigning a new reference. + This can be accomplished via the ref assignment function shown below: + + sword OCIRefAssign( OCIEnv *env, OCIError *err, const OCIRef *source, + OCIRef **target ); + + Note that the 'target' parameter of OCIRefAssign() is of type + 'OCIRef**'. Hence OCICollGetElem() returns 'OCIRef**'. + If '*target == NULL' a new ref will be allocated by OCIRefAssign() + and returned via the 'target' parameter. + + Similarly, if the collection element was of type string (OCIString*), + OCICollGetElem() returns pointer to string handle + (i.e. OCIString**). If a new string is assigned, via + OCIStringAssign() or OCIStringAssignText() the type of the target + must be 'OCIString **'. + + If the collection element is of type Oracle number, OCICollGetElem() + returns OCINumber*. The prototype of OCINumberAssign() is shown below: + + sword OCINumberAssign(OCIError *err, const OCINumber *from, + OCINumber *to); + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is NULL. + OCI_ERROR if + any of the input parameters is null + */ + +/*------------------------- OCICollGetElemArray -----------------------------*/ + +sword OCICollGetElemArray( OCIEnv *env, OCIError *err, const OCIColl *coll, + sb4 index, boolean *exists, void **elem, + void **elemind, uword *nelems); +/* + NAME: OCICollGetElemArray - OCIColl GET pointers to elements from given index + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode. + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + coll (IN) - pointers to the elements in this collection is returned + index (IN) - starting index of the element + exists (OUT) - set to FALSE if element at the specified index does + not exist else TRUE + elem (OUT) - address of the desired elements is returned + elemind (OUT) [optional] - address of the null indicators information + is returned; if (elemind == NULL) then the null indicator + information will NOT be returned + nelems(IN/OUT) - Upper bound of elem and/or elemind array + DESCRIPTION: + Get the address of the elements from the given position. Optionally + this function also returns the address of the element's null indicator + information. + + The following table describes for each collection element type + what the corresponding element pointer type is. The element pointer + is returned via the 'elem' parameter of OCICollGetElem(). + + Element Type *elem is set to + ----------------------- --------------- + Oracle Number (OCINumber) OCINumber* + Date (OCIDate) OCIDate* + Variable-length string (OCIString*) OCIString** + Variable-length raw (OCIRaw*) OCIRaw** + object reference (OCIRef*) OCIRef** + lob locator (OCILobLocator*) OCILobLocator** + object type (e.g. person) person* + + The element pointer returned by OCICollGetElem() is in a form + such that it can not only be used to access the + element data but also is in a form that can be used as the target + (i.e left-hand-side) of an assignment statement. + + For example, assume the user is iterating over the elements of + a collection whose element type is object reference (OCIRef*). A call + to OCICollGetElem() returns pointer to a reference handle + (i.e. OCIRef**). After getting, the pointer to the collection + element, the user may wish to modify it by assigning a new reference. + This can be accomplished via the ref assignment function shown below: + + sword OCIRefAssign( OCIEnv *env, OCIError *err, const OCIRef *source, + OCIRef **target ); + + Note that the 'target' parameter of OCIRefAssign() is of type + 'OCIRef**'. Hence OCICollGetElem() returns 'OCIRef**'. + If '*target == NULL' a new ref will be allocated by OCIRefAssign() + and returned via the 'target' parameter. + + Similarly, if the collection element was of type string (OCIString*), + OCICollGetElem() returns pointer to string handle + (i.e. OCIString**). If a new string is assigned, via + OCIStringAssign() or OCIStringAssignText() the type of the target + must be 'OCIString **'. + + If the collection element is of type Oracle number, OCICollGetElem() + returns OCINumber*. The prototype of OCINumberAssign() is shown below: + + sword OCINumberAssign(OCIError *err, const OCINumber *from, + OCINumber *to); + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is NULL. + OCI_ERROR if + any of the input parameters is null + */ + +/*----------------------- OCICollAssignElem ---------------------------------*/ + +sword OCICollAssignElem( OCIEnv *env, OCIError *err, sb4 index, + const void *elem, + const void *elemind, OCIColl *coll ); +/* + NAME: OCICollAssignElem - OCIColl ASsign Element + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode. + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + index (IN) - index of the element whose is assigned to + elem (IN) - element which is assigned from (source element) + elemind (IN) [optional] - pointer to the element's null indicator + information; if (elemind == NULL) then the null indicator + information of the assigned element will be set to non-null. + coll (IN/OUT) - collection to be updated + DESCRIPTION: + Assign the given element value 'elem' to the element at coll[index]. + If the collection is of type nested table, the element at the given + index may not exist (i.e. may have been deleted). In this case, the + given element is inserted at index 'index'. + Otherwise, the element at index 'index' is updated with the value + of 'elem'. + + Note that the given element is deep-copied and + 'elem' is strictly an input parameter. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is NULL. + OCI_ERROR if + any of the input parameters is null + out of memory error + given index is out of bounds of the given collection + */ + +/*--------------------------- OCICollAssign ---------------------------------*/ + +sword OCICollAssign( OCIEnv *env, OCIError *err, const OCIColl *rhs, + OCIColl *lhs ); +/* + NAME: OCICollAssign - OCIColl ASsiGn collection + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode. + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + rhs (IN) - collection to be assigned from + lhs (OUT) - collection to be assigned to + DESCRIPTION: + Assign 'rhs' to 'lhs'. The 'lhs' collection may be decreased or + increased depending upon the size of 'rhs'. If the 'lhs' contains + any elements then the elements will be deleted prior to the + assignment. This function performs a deep-copy. The memory for the + elements comes from the object cache. + + An error is returned if the element types of the lhs and rhs + collections do not match. Also, an error is returned if the + upper-bound of the lhs collection is less than the current number of + elements in the rhs collection. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is NULL. + OCI_ERROR if + any of the input parameters is null + out of memory error + type mis-match of lhs and rhs collections + upper-bound of lhs collection is less than the current number of + elements in the rhs collection + */ + +/*--------------------------- OCICollAppend ---------------------------------*/ + +sword OCICollAppend( OCIEnv *env, OCIError *err, const void *elem, + const void *elemind, OCIColl *coll ); +/* + NAME: OCICollAppend - OCIColl APPend collection + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode. + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + elem (IN) - pointer to the element which is appended to the end + of the given collection + elemind (IN) [optional] - pointer to the element's null indicator + information; if (elemind == NULL) then the null indicator + information of the appended element will be set to non-null. + coll (IN/OUT) - updated collection + DESCRIPTION: + Append the given element to the end of the given collection. + Appending an element is equivalent to: + - increasing the size of the collection by 1 element + - updating (deep-copying) the last element's data with the given + element's data + + Note that the pointer to the given element 'elem' will not be saved + by this function. So 'elem' is strictly an input parameter. + An error is returned if the current size of the collection + is equal to the max size (upper-bound) of the collection prior to + appending the element. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is NULL. + OCI_ERROR if + any of the input parameters is null + out of memory error + current size of collection == max size of the collection + */ + +/*----------------------------- OCICollTrim ---------------------------------*/ + +sword OCICollTrim( OCIEnv *env, OCIError *err, sb4 trim_num, + OCIColl *coll ); +/* + NAME: OCICollTrim - OCIColl Trim elements from the end of the collection + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode. + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + trim_num (IN) - number of elements to trim + coll (IN/OUT) - 'trim_num' of elements are removed (freed) from the + end of the collection + DESCRIPTION: + Trim the collection by the given number of elements. The elements are + removed from the end of the collection. + + An error is returned if the 'trim_num' is greater than the current + size of the collection. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is NULL. + OCI_ERROR if + any of the input parameters is null + 'trim_num' is greater than the current size of the collection. + */ + +/*--------------------------- OCICollIsLocator ------------------------------*/ + +sword OCICollIsLocator(OCIEnv *env, OCIError *err, const OCIColl *coll, + boolean *result ); +/* +Name: OCICollIsLocator - OCIColl indicates whether a collection is locator + based or not. +Parameters: + env(IN) - pointer to OCI environment handle + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + coll (IN) - collection item. + result (OUT) - TRUE if the collection item is a locator, FALSE + otherwise +Description: + Returns TRUE in the result OUT parameter if the collection item is a + locator, otherwise returns FALSE. +Returns: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is NULL. +*/ + +/*---------------------------- OCIIterCreate --------------------------------*/ + +sword OCIIterCreate( OCIEnv *env, OCIError *err, const OCIColl *coll, + OCIIter **itr ); +/* + NAME: OCIIterCreate - OCIColl Create an ITerator to scan the collection + elements + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode. + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + coll (IN) - collection which will be scanned; the different + collection types are varray and nested table + itr (OUT) - address to the allocated collection iterator is + returned by this function + DESCRIPTION: + Create an iterator to scan the elements of the collection. The + iterator is created in the object cache. The iterator is initialized + to point to the beginning of the collection. + + If the next function (OCIIterNext) is called immediately + after creating the iterator then the first element of the collection + is returned. + If the previous function (OCIIterPrev) is called immediately after + creating the iterator then "at beginning of collection" error is + returned. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is NULL. + OCI_ERROR if + any of the input parameters is null + out of memory error + */ + +/*----------------------------- OCIIterDelete ------------------------------*/ + +sword OCIIterDelete( OCIEnv *env, OCIError *err, OCIIter **itr ); +/* + NAME: OCIIterDelete - OCIColl Delete ITerator + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode. + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + itr (IN/OUT) - the allocated collection iterator is destroyed and + the 'itr' is set to NULL prior to returning + DESCRIPTION: + Delete the iterator which was previously created by a call to + OCIIterCreate. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is NULL. + OCI_ERROR if + any of the input parameters is null + to be discovered + */ + +/*----------------------------- OCIIterInit ---------------------------------*/ + +sword OCIIterInit( OCIEnv *env, OCIError *err, const OCIColl *coll, + OCIIter *itr ); +/* + NAME: OCIIterInit - OCIColl Initialize ITerator to scan the given + collection + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode. + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + coll (IN) - collection which will be scanned; the different + collection types are varray and nested table + itr (IN/OUT) - pointer to an allocated collection iterator + DESCRIPTION: + Initializes the given iterator to point to the beginning of the + given collection. This function can be used to: + + a. reset an iterator to point back to the beginning of the collection + b. reuse an allocated iterator to scan a different collection + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is NULL. + OCI_ERROR if + any of the input parameters is null + */ + +/*------------------------ OCIIterGetCurrent --------------------------------*/ + +sword OCIIterGetCurrent( OCIEnv *env, OCIError *err, const OCIIter *itr, + void **elem, void **elemind ); +/* + NAME: OCIIterGetCurrent - OCIColl Iterator based, get CURrent collection + element + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode. + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + itr (IN) - iterator which points to the current element + elem (OUT) - address of the element pointed by the iterator is returned + elemind (OUT) [optional] - address of the element's null indicator + information is returned; if (elemind == NULL) then the null + indicator information will NOT be returned + DESCRIPTION: + Returns pointer to the current element and its corresponding null + information. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is NULL. + OCI_ERROR if + any of the input parameters is null + */ + +/*------------------------------ OCIIterNext --------------------------------*/ + +sword OCIIterNext( OCIEnv *env, OCIError *err, OCIIter *itr, + void **elem, void **elemind, boolean *eoc ); +/* + NAME: OCIIterNext - OCIColl Iterator based, get NeXT collection element + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode. + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + itr (IN/OUT) - iterator is updated to point to the next element + elem (OUT) - after updating the iterator to point to the next element, + address of the element is returned + elemind (OUT) [optional] - address of the element's null indicator + information is returned; if (elemind == NULL) then the null + indicator information will NOT be returned + eoc (OUT) - TRUE if iterator is at End Of Collection (i.e. next + element does not exist) else FALSE + DESCRIPTION: + Returns pointer to the next element and its corresponding null + information. The iterator is updated to point to the next element. + + If the iterator is pointing to the last element of the collection + prior to executing this function, then calling this function will + set eoc flag to TRUE. The iterator will be left unchanged in this + situation. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is NULL. + OCI_ERROR if + any of the input parameters is null + */ + +/*------------------------------ OCIIterPrev --------------------------------*/ + +sword OCIIterPrev( OCIEnv *env, OCIError *err, OCIIter *itr, + void **elem, void **elemind, boolean *boc ); +/* + NAME: OCIIterPrev - OCIColl Iterator based, get PReVious collection element + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode. + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + itr (IN/OUT) - iterator is updated to point to the previous + element + elem (OUT) - after updating the iterator to point to the previous + element, address of the element is returned + elemind (OUT) [optional] - address of the element's null indicator + information is returned; if (elemind == NULL) then the null + indicator information will NOT be returned + boc (OUT) - TRUE if iterator is at Beginning Of Collection (i.e. + previous element does not exist) else FALSE. + DESCRIPTION: + Returns pointer to the previous element and its corresponding null + information. The iterator is updated to point to the previous element. + + If the iterator is pointing to the first element of the collection + prior to executing this function, then calling this function will + set 'boc' to TRUE. The iterator will be left unchanged in this + situation. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is NULL. + OCI_ERROR if + any of the input parameters is null + */ + +/*****************************************************************************/ +/* FUNCTIONS WHICH OPERATE ONLY ON NESTED TABLE OCITable*() */ +/*****************************************************************************/ + +/*---------------------------- OCITableSize ---------------------------------*/ + +sword OCITableSize( OCIEnv *env, OCIError *err, const OCITable *tbl, + sb4 *size); +/* + NAME: OCITableSize - OCITable return current SIZe of the given + nested table (not including deleted elements) + PARAMETERS: + env(IN) - pointer to OCI environment handle + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + tbl (IN) - nested table whose number of elements is returned + size (OUT) - current number of elements in the nested table. The count + does not include deleted elements. + DESCRIPTION: + Returns the count of elements in the given nested table. + + The count returned by OCITableSize() will be decremented upon + deleting elements from the nested table. So, this count DOES NOT + includes any "holes" created by deleting elements. + For example: + + OCITableSize(...); + // assume 'size' returned is equal to 5 + OCITableDelete(...); // delete one element + OCITableSize(...); + // 'size' returned will be equal to 4 + + To get the count plus the count of deleted elements use + OCICollSize(). Continuing the above example, + + OCICollSize(...) + // 'size' returned will still be equal to 5 + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is NULL. + OCI_ERROR if + error during loading of nested table into object cache + any of the input parameters is null + */ + +/*---------------------- OCITableExists ---------------------------------*/ + +sword OCITableExists( OCIEnv *env, OCIError *err, const OCITable *tbl, + sb4 index, boolean *exists ); +/* + NAME: OCITableExists - OCITable test whether element at the given index + EXIsts + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode. + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + tbl (IN) - table in which the given index is checked + index (IN) - index of the element which is checked for existence + exists (OUT) - set to TRUE if element at given 'index' exists + else set to FALSE + DESCRIPTION: + Test whether an element exists at the given 'index'. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is NULL. + OCI_ERROR if + any of the input parameters is null + */ + +/*--------------------------- OCITableDelete -------------------------------*/ + +sword OCITableDelete( OCIEnv *env, OCIError *err, sb4 index, + OCITable *tbl ); +/* + NAME: OCITableDelete - OCITable DELete element at the specified index + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode. + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + index (IN) - index of the element which must be deleted + tbl (IN) - table whose element is deleted + DESCRIPTION: + Delete the element at the given 'index'. Note that the position + ordinals of the remaining elements of the table is not changed by the + delete operation. So delete creates "holes" in the table. + + An error is returned if the element at the specified 'index' has + been previously deleted. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is NULL. + OCI_ERROR if + any of the input parameters is null + given index is not valid + */ + +/*--------------------------- OCITableFirst ---------------------------------*/ + +sword OCITableFirst( OCIEnv *env, OCIError *err, const OCITable *tbl, + sb4 *index ); +/* + NAME: OCITableFirst - OCITable return FirST index of table + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode. + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + tbl (IN) - table which is scanned + index (OUT) - first index of the element which exists in the given + table is returned + DESCRIPTION: + Return the first index of the element which exists in the given + table. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is NULL. + OCI_ERROR if + table is empty + */ + +/*---------------------------- OCITableLast ---------------------------------*/ + +sword OCITableLast( OCIEnv *env, OCIError *err, const OCITable *tbl, + sb4 *index ); +/* + NAME: OCITableFirst - OCITable return LaST index of table + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode. + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + tbl (IN) - table which is scanned + index (OUT) - last index of the element which exists in the given + table is returned + DESCRIPTION: + Return the last index of the element which exists in the given + table. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is NULL. + OCI_ERROR if + table is empty + */ + +/*---------------------------- OCITableNext ---------------------------------*/ + +sword OCITableNext( OCIEnv *env, OCIError *err, sb4 index, + const OCITable *tbl, sb4 *next_index, + boolean *exists ); +/* + NAME: OCITableNext - OCITable return NeXT available index of table + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode. + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + index (IN) - starting at 'index' the index of the next element + which exists is returned + tbl (IN) - table which is scanned + next_index (OUT) - index of the next element which exists + is returned + exists (OUT) - FALSE if no next index available else TRUE + DESCRIPTION: + Return the smallest position j, greater than 'index', such that + exists(j) is TRUE. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is NULL. + OCI_ERROR if + no next index available + */ + +/*---------------------------- OCITablePrev ---------------------------------*/ + +sword OCITablePrev( OCIEnv *env, OCIError *err, sb4 index, + const OCITable *tbl, sb4 *prev_index, + boolean *exists ); +/* + NAME: OCITablePrev - OCITable return PReVious available index of table + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode. + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + index (IN) - starting at 'index' the index of the previous element + which exists is returned + tbl (IN) - table which is scanned + prev_index (OUT) - index of the previous element which exists + is returned + exists (OUT) - FALSE if no next index available else TRUE + DESCRIPTION: + Return the largest position j, less than 'index', such that + exists(j) is TRUE. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is NULL. + OCI_ERROR if + no previous index available + */ + +/*------------------------ OCINumberToLnx -----------------------------------*/ +/* void OCINumberToLnx(/o_ OCINumber *num _o/); */ + +#define OCINumberToLnx(num) ((lnxnum_t *)num) + +/* + NAME: OCINumberToLnx + PARAMETERS: + num (IN) - OCINumber to convert ; + DESCRIPTION: + Converts OCINumber to its internal lnx format + This is not to be used in Public interfaces , but + has been provided due to special requirements from + SQLPLUS development group as they require to call + Core funtions directly . +*/ + +/* OCI representation of XMLType */ +typedef struct OCIXMLType OCIXMLType; + +/* OCI representation of OCIDomDocument */ +typedef struct OCIDOMDocument OCIDOMDocument; + +/* OCI representation for the Binary XML repository context */ +typedef struct OCIBinXmlReposCtx OCIBinXmlReposCtx; + +#endif /* ORL_ORACLE */ diff --git a/OCI/include/oro.h b/OCI/include/oro.h new file mode 100644 index 0000000..e825a5c --- /dev/null +++ b/OCI/include/oro.h @@ -0,0 +1,883 @@ +/* Copyright (c) 1994, 2003, Oracle Corporation. All rights reserved. */ + +/* + NAME + OCI - Oracle Object Interface for External/Internal/Kernel Clients + + DESCRIPTION + This header file contains Oracle object interface definitions which + can be included by external user applications, tools, as well as + the kernel. It defines types and constants that are common to all + object interface which is being defined in several other header files + (e.g., ori.h, ort.h, and orl.h). + + RELATED DOCUMENTS + TBD + + INSPECTION STATUS [[ deletable if no inspection ]] + Inspection date: [[ date of the last logging meeting ]] + Inspection status: [[ exited, not exited, or N/A if exit is not a goal ]] + Estimated increasing cost defects per page: + Rule sets: [[ rule sets inspected against or planned to be + inspected against ]] + + ACCEPTANCE REVIEW STATUS [[ deletable if no approval review ]] + Review date: [[ date of the meeting where issues were logged and the + approval status was decided ]] + Review status: [[ current status: accepted, conditionally accepted, + major revision required, rejected ]] + Reviewers: [[ names of the members on the review team ]] + + PUBLIC FUNCTIONS + + EXAMPLES + Examples are given in the description of each function or macro where + relevant. + + MODIFIED + mnanal 06/09/03 - backout of fix 2836388 + mnanal 05/14/03 - bug-2836388 + srseshad 11/27/02 - Change OCI_TYPECODE_BFLOAT/BDOUBLE codes + rxgovind 10/09/02 - add OCI_TYPECODE_UROWID + mxyang 09/17/02 - grabtrans 'mmorsi_obj_float' + srseshad 09/11/02 - + srseshad 09/01/02 - + aahluwal 06/03/02 - bug 2360115 + celsbern 10/19/01 - merge LOG to MAIN + rxgovind 10/16/01 - update typecodes + rxgovind 09/19/01 - add typecodes + rkasamse 08/15/01 - add OCI_DURATION_USER_CALLBACK + jchai 09/24/01 - add type code for PLS_INTEGER + porangas 08/22/01 - Fix bug#1776434 + schatter 04/09/01 - merge 1456235: define OCI_DURATION_INVALID + rdani 10/12/00 - 1449943 NOCOPY and PIPELINE + ciyer 05/26/00 - short names for abstract, overriding + rkasamse 05/25/00 - OCCI enhancements + smuralid 05/11/00 - OCITypeMethodFlags - add NOT INSTANTIABLE, OVERRIDING + rxgovind 05/09/00 - add OCI_TYPECODE_NONE + tnbui 07/28/99 - Remove OCI_TYPECODE_TIMESTAMP_ITZ + tnbui 07/21/99 - TS LOCAL TZ + thoang 06/21/99 - Add OCI_TYPECODE_TIMESTAMP_ITZ + thoang 03/04/99 - Add datetime datatypes + rkasamse 10/20/98 - add OCI_ATTR_CACHE_ARRAYFLUSH + rkasamse 10/29/98 - add OCI_DURATION_CALLOUT + rkasamse 04/28/98 - OCI_OBJECT_DETECTCHANGE -> OCI_ATTR_OBJECT_DETECTCHAN + rkasamse 04/28/98 - OCI_OBJECT_NEWNOTNULL -> OCI_ATTR_OBJECT_NEWNOTNULL + rkasamse 04/23/98 - add OCI_OBJECT_DETECTCHANGE + rkasamse 04/03/98 - add OCI_OBJECT_NEWNOTNULL + pmitra 04/01/98 - OCI_LOCK_X_NOWAIT added + rxgovind 02/18/98 - add OCI_TYPECODE_OPAQUE + rkasamse 02/13/98 - Add OCI_DURATION_PROCESS + cxcheng 07/28/97 - fix compile with SLSHORTNAME + skrishna 07/14/97 - add OCIObjectGetProperty + cxcheng 04/30/97 - make OCITypeParamMode values consistent with PL/SQL + skrishna 04/28/97 - undocument OCIObjectProperty & OCIObjectEvent + cxcheng 03/29/97 - remove all remaining short names + sthakur 03/20/97 - add casts to constants + cxcheng 02/21/97 - temporarily put SLSHORTNAME for PL/SQL + cxcheng 02/06/97 - take out short name support except with SLSHORTNAME + lchidamb 01/20/97 - update OCIRef comments + sgollapu 11/19/96 - Add OCI type codes for BOOL,REC,and TAB + cxcheng 11/19/96 - more typecode changes + cxcheng 11/13/96 - add #include for ocidfn.h + cxcheng 11/13/96 - add OCI_TYPECODE_ADT for compatibility + cxcheng 11/12/96 - add SQLT_NCO for named collection + cxcheng 11/11/96 - more changes to typecodes + cxcheng 11/07/96 - #define OCI_TYPECODE_MLSLABEL to SQLT_LAB + cxcheng 11/06/96 - fix #define omission for OROTCNAT + cxcheng 10/30/96 - move OCI_TYPECODE_* to ocidfn.h as SQLT_* + cxcheng 10/28/96 - more beautification changes + jboonleu 10/29/96 - add flags for freeing object + dchatter 10/26/96 - delete redef of OCISvcCtx, OCIError, OCIEnv + cxcheng 10/15/96 - more changes + cxcheng 10/14/96 - more final fixes to constants + mluong 10/11/96 - + mluong 10/11/96 - KOCON and KONSP are in lowercase + mluong 10/11/96 - add some define per Calvin + cxcheng 10/09/96 - add #define for OROOCOSFN to OCI_COPY_NOREF + jboonleu 10/08/96 - change OROOCOSFN to OCICopyFlag + jboonleu 10/07/96 - use new OCI names for cache options + cxcheng 10/07/96 - add OROTCS02 for KOTTCBRI and OROTCS03 as spare + cxcheng 10/07/96 - more lint fixes + cxcheng 10/02/96 - move oronsp to ko.h as konsp + cxcheng 10/01/96 - add long names for readability + cxcheng 10/01/96 - remove orotty and orotal + rjenkins 09/28/96 - 2k char 4k varchar2 + jboonleu 09/27/96 - add macro used only in beta2 + cxcheng 09/27/96 - move oroenv to oroenv.h + cxcheng 09/24/96 - remove unnecessary orotyp + cxcheng 09/25/96 - add typecode OROTCS01 as placeholder for lob pointer + cxcheng 09/20/96 - add TDO load option orotgo + jboonleu 09/18/96 - add OROOPOREC + jboonleu 09/10/96 - add OROOPODFL + jweisz 08/27/96 - add SQL internal typecode OROTCS00 + cxcheng 08/02/96 - add PLSQL internal typecodes OROTCP.. + cxcheng 08/01/96 - add OROTCFAR to fill up space left by OROTCCAR + jboonleu 07/16/96 - new pin option + cxcheng 06/18/96 - add casts to OROTNOPRE and OROTNOSCL + cxcheng 05/29/96 - change OROTCNPT back to OROTCDOM + vkrishna 05/27/96 - add OROTCCAR + cxcheng 05/17/96 - replace OROTCFAR with OROTCCAR + cxcheng 05/08/96 - change orotmf from ub1 to ub2 + cxcheng 05/07/96 - fix public defines for method types + cxcheng 04/30/96 - change OROTCDOM to OROTCNPT + cxcheng 04/15/96 - remove obsolete OROTTYICT + jboonleu 04/12/96 - add new pin option + sthakur 04/12/96 - add indicator type and indicator status + cxcheng 04/10/96 - add function parameter codes for ORT/KOT + cxcheng 04/03/96 - replace OROTCFAR as OROTCCAR + jwijaya 03/29/96 - add OROTTCCAR + jwijaya 03/27/96 - better comments for orotc + cxcheng 02/23/96 - add typecodes for SMALLINT and VARCHAR2 + skrishna 02/22/96 - add oroind - null indicator type + cxcheng 02/21/96 - change lob character codes to OROTCCLB, OROTCBLB... + jboonleu 02/06/96 - new value for predefined duration + cxcheng 01/12/96 - add OROTCCLO, OROTCBLO, OROTCFIL to orotc + cxcheng 12/05/95 - add OROTCDOM and OROTCAAT to orotc + skotsovo 10/30/95 - reserve space for internal 'oid' type + jwijaya 10/20/95 - support variable-length ref + cxcheng 10/03/95 - add OROTMFOR for ordering function to orotmf + cxcheng 10/03/95 - Adding the ordering function type to orotmf + jboonleu 09/28/95 - set OROODTPRE + jboonleu 09/25/95 - add oroodt + skotsovo 03/10/95 - update to only include release 1 + jboonleu 02/15/95 - add OROOPOREC, remove orocro, oroolo + skotsovo 01/30/95 - add default max lengths for varrays and vstrings + skotsovo 01/24/95 - categorize sint32, double, and real as number types + (with precision and scale) instead of scalar types. + skotsovo 12/20/94 - add release 1 types + skotsovo 12/12/94 - update according to new ots doc + skotsovo 12/01/94 - add default precision and scale + jwijaya 11/15/94 - rename ORONSPTAB to ORONSPEXT + jwijaya 10/25/94 - tint + jwijaya 10/06/94 - add namespace + jwijaya 10/02/94 - connection handle -> connection number + skotsovo 09/12/94 - keep 0 as uninitialized value for ORT consts + skotsovo 08/24/94 - fix orotec + skotsovo 08/17/94 - modify type code names + skotsovo 08/12/94 - fix 141 lint errors + skotsovo 07/25/94 - modify categorization of complex types (orotc) + skotsovo 07/07/94 - change typecode enum values & add decimal type + skotsovo 07/01/94 - change order of typecodes + jwijaya 06/15/94 - review + jboonleu 06/13/94 - add comments for the object cache options + jwijaya 06/13/94 - adhere to the header file template + skotsovo 06/09/94 - make ots scalar type names consistent with the ots + document + jwijaya 06/07/94 - include oratypes.h instead of s.h + skotsovo 05/24/94 - change typecodes + jwijaya 05/23/94 - fix comments of ororef + skotsovo 05/19/94 - remove type composition + skotsovo 05/09/94 - modified orotc according to new OTS document + jwijaya 05/03/94 - oroid and ororef + jwijaya 01/26/94 - Creation +*/ + + +#ifndef ORATYPES +#include +#endif + +#ifndef OCIDFN_ORACLE +#include +#endif + +#ifndef ORO_ORACLE +#define ORO_ORACLE + +/*---------------------------------------------------------------------------*/ +/* SHORT NAMES SUPPORT SECTION */ +/*---------------------------------------------------------------------------*/ + +#ifdef SLSHORTNAME + +/* the following are short names that are only supported on IBM mainframes + with the SLSHORTNAME defined. + With this all subsequent long names will actually be substituted with + the short names here */ + +#define OCIDuration oroodt +#define OCIInd oroind +#define OCILockOpt oroolm +#define OCIMarkOpt oroomo +#define OCIObjectEvent orocev +#define OCIObjectProperty oroopr +#define OCIPinOpt oroopo +#define OCIRef ororef +#define OCIRefreshOpt orooro +#define OCITypeCode orotc +#define OCITypeEncap orotec +#define OCITypeGetOpt orotgo +#define OCITypeMethodFlag orotmf +#define OCITypeParamMode orotpm +#define OCIObjectPropId oroopi +#define OCIObjectLifetime oroolft +#define OCIObjectMarkstatus oroomst +#define OCI_LOCK_NONE OROOLMNUL +#define OCI_LOCK_X OROOLMX +#define OCI_LOCK_X_NOWAIT OROOLMXNW +#define OCI_MARK_DEFAULT OROOMODFL +#define OCI_MARK_NONE OROOMONON +#define OCI_MARK_UPDATE OROOMOUPD +#define OCI_OBJECTEVENT_AFTER_FLUSH OROCEVAFL +#define OCI_OBJECTEVENT_AFTER_REFRESH OROCEVARF +#define OCI_OBJECTEVENT_BEFORE_FLUSH OROCEVBFL +#define OCI_OBJECTEVENT_BEFORE_REFRESH OROCEVBRF +#define OCI_OBJECTEVENT_WHEN_LOCK OROCEVWLK +#define OCI_OBJECTEVENT_WHEN_MARK_DELETED OROCEVWDL +#define OCI_OBJECTEVENT_WHEN_MARK_UPDATED OROCEVWUP +#define OCI_OBJECTEVENT_WHEN_UNMARK OROCEVWUM +#define OCI_OBJECTPROP_DIRTIED OROOPRDRT +#define OCI_OBJECTPROP_LOADED OROOPRLOD +#define OCI_OBJECTPROP_LOCKED OROOPRLCK +#define OCI_PIN_ANY OROOPOANY +#define OCI_PIN_DEFAULT OROOPODFL +#define OCI_PIN_LATEST OROOPOLST +#define OCI_PIN_RECENT OROOPOREC +#define OCI_REFRESH_LOADED OROOROLOD +#define OCI_TYPEENCAP_PRIVATE OROTECPVT +#define OCI_TYPEENCAP_PUBLIC OROTECPUB +#define OCI_TYPEGET_ALL OROTGOALL +#define OCI_TYPEGET_HEADER OROTGOHDR +#define OCI_TYPEMETHOD_CONSTANT OROTMCON +#define OCI_TYPEMETHOD_CONSTRUCTOR OROTMCSTR +#define OCI_TYPEMETHOD_DESTRUCTOR OROTMDSTR +#define OCI_TYPEMETHOD_INLINE OROTMINL +#define OCI_TYPEMETHOD_MAP OROTMMAP +#define OCI_TYPEMETHOD_OPERATOR OROTMOP +#define OCI_TYPEMETHOD_ORDER OROTMOR +#define OCI_TYPEMETHOD_RNDS OROTMRDS +#define OCI_TYPEMETHOD_RNPS OROTMRPS +#define OCI_TYPEMETHOD_SELFISH OROTMSLF +#define OCI_TYPEMETHOD_VIRTUAL OROTMVRT +#define OCI_TYPEMETHOD_WNDS OROTMWDS +#define OCI_TYPEMETHOD_WNPS OROTMWPS +#define OCI_TYPEMETHOD_ABSTRACT OROTMABSTRACT +#define OCI_TYPEMETHOD_OVERRIDING OROTMOVERRIDING +#define OCI_TYPEMETHOD_PIPELINED OROTMPIPELINED +#define OCI_TYPEPARAM_BYREF OROTPMREF +#define OCI_TYPEPARAM_IN OROTPMIN +#define OCI_TYPEPARAM_INOUT OROTPMIO +#define OCI_TYPEPARAM_OUT OROTPMOUT +#define OCI_TYPEPARAM_OUTNCPY OROTPMOUTNCPY +#define OCI_TYPEPARAM_INOUTNCPY OROTPMIONCPY + +#endif /* SLSHORTNAME */ + + +/*---------------------------------------------------------------------------*/ +/* PUBLIC TYPES, CONSTANTS AND MACROS */ +/*---------------------------------------------------------------------------*/ + +/*---------------------------------------------------------------------------*/ +/* GENERAL OBJECT TYPES, CONSTANTS, MACROS */ +/*---------------------------------------------------------------------------*/ + +/*------------------------- OBJECT REFERENCE (REF) --------------------------*/ + +typedef struct OCIRef OCIRef; +/* + * OCIRef - OCI object REFerence + * + * In the Oracle object runtime environment, an object is identified by an + * object reference (ref) which contains the object identifier plus other + * runtime information. The contents of a ref is opaque to clients. Use + * OCIObjectNew() to construct a ref. + */ + + +/*--------------------------- OBJECT INDICATOR ------------------------------*/ + +typedef sb2 OCIInd; +/* + * OCIInd -- a variable of this type contains (null) indicator information + */ + +#define OCI_IND_NOTNULL (OCIInd)0 /* not NULL */ +#define OCI_IND_NULL (OCIInd)(-1) /* NULL */ +#define OCI_IND_BADNULL (OCIInd)(-2) /* BAD NULL */ +#define OCI_IND_NOTNULLABLE (OCIInd)(-3) /* not NULLable */ + +/*---------------------------------------------------------------------------*/ +/* OBJECT CACHE */ +/*---------------------------------------------------------------------------*/ + +/* To enable object change detection mode, set this to TRUE */ +#define OCI_ATTR_OBJECT_DETECTCHANGE 0x00000020 + +/* To enable object creation with non-NULL attributes by default, set the + following to TRUE. + By default, object is created with NULL attributes +*/ +#define OCI_ATTR_OBJECT_NEWNOTNULL 0x00000010 + +/* To enable sorting of the objects that belong to the same table + before being flushed through OCICacheFlush. + Please note that by enabling this object cache will not be flushing + the objects in the same order they were dirtied */ +#define OCI_ATTR_CACHE_ARRAYFLUSH 0x00000040 + +/*--------------------------- OBJECT PIN OPTION -----------------------------*/ + +enum OCIPinOpt +{ + /* 0 = uninitialized */ + OCI_PIN_DEFAULT = 1, /* default pin option */ + OCI_PIN_ANY = 3, /* pin any copy of the object */ + OCI_PIN_RECENT = 4, /* pin recent copy of the object */ + OCI_PIN_LATEST = 5 /* pin latest copy of the object */ +}; +typedef enum OCIPinOpt OCIPinOpt; + +/* + * OCIPinOpt - OCI object Pin Option + * + * In the Oracle object runtime environment, the program has the option to + * specify which copy of the object to pin. + * + * OCI_PINOPT_DEFAULT pins an object using the default pin option. The default + * pin option can be set as an attribute of the OCI environment handle + * (OCI_ATTR_PINTOPTION). The value of the default pin option can be + * OCI_PINOPT_ANY, OCI_PINOPT_RECENT, or OCI_PIN_LATEST. The default option + * is initialized to OCI_PINOPT_ANY. + * + * OCI_PIN_ANY pins any copy of the object. The object is pinned + * using the following criteria: + * If the object copy is not loaded, load it from the persistent store. + * Otherwise, the loaded object copy is returned to the program. + * + * OCI_PIN_RECENT pins the latest copy of an object. The object is + * pinned using the following criteria: + * If the object is not loaded, load the object from the persistent store + * from the latest version. + * If the object is not loaded in the current transaction and it is not + * dirtied, the object is refreshed from the latest version. + * Otherwise, the loaded object copy is returned to the program. + * + * OCI_PINOPT_LATEST pins the latest copy of an object. The object copy is + * pinned using the following criteria: + * If the object copy is not loaded, load it from the persistent store. + * If the object copy is loaded and dirtied, it is returned to the program. + * Otherwise, the loaded object copy is refreshed from the persistent store. + */ + + + +/*--------------------------- OBJECT LOCK OPTION ----------------------------*/ + +enum OCILockOpt +{ + /* 0 = uninitialized */ + OCI_LOCK_NONE = 1, /* null (same as no lock) */ + OCI_LOCK_X = 2, /* exclusive lock */ + OCI_LOCK_X_NOWAIT = 3 /* exclusive lock, do not wait */ +}; +typedef enum OCILockOpt OCILockOpt; +/* + * OCILockOpt - OCI object LOCK Option + * + * This option is used to specify the locking preferences when an object is + * loaded from the server. + */ + + +/*------------------------- OBJECT MODIFYING OPTION -------------------------*/ + +enum OCIMarkOpt +{ + /* 0 = uninitialized */ + OCI_MARK_DEFAULT = 1, /* default (the same as OCI_MARK_NONE) */ + OCI_MARK_NONE = OCI_MARK_DEFAULT, /* object has not been modified */ + OCI_MARK_UPDATE /* object is to be updated */ +}; +typedef enum OCIMarkOpt OCIMarkOpt; +/* + * OCIMarkOpt - OCI object Mark option + * + * When the object is marked updated, the client has to specify how the + * object is intended to be changed. + */ + +/*-------------------------- OBJECT Duration --------------------------------*/ + +typedef ub2 OCIDuration; + +#define OCI_DURATION_INVALID 0xFFFF /* Invalid duration */ +#define OCI_DURATION_BEGIN (OCIDuration)10 + /* beginning sequence of duration */ +#define OCI_DURATION_NULL (OCIDuration)(OCI_DURATION_BEGIN-1) + /* null duration */ +#define OCI_DURATION_DEFAULT (OCIDuration)(OCI_DURATION_BEGIN-2) /* default */ +#define OCI_DURATION_USER_CALLBACK (OCIDuration)(OCI_DURATION_BEGIN-3) +#define OCI_DURATION_NEXT (OCIDuration)(OCI_DURATION_BEGIN-4) + /* next special duration */ +#define OCI_DURATION_SESSION (OCIDuration)(OCI_DURATION_BEGIN) + /* the end of user session */ +#define OCI_DURATION_TRANS (OCIDuration)(OCI_DURATION_BEGIN+1) + /* the end of user transaction */ +/****************************************************************************** +** DO NOT USE OCI_DURATION_CALL. IT IS UNSUPPORTED ** +** WILL BE REMOVED/CHANGED IN A FUTURE RELEASE ** +******************************************************************************/ +#define OCI_DURATION_CALL (OCIDuration)(OCI_DURATION_BEGIN+2) + /* the end of user client/server call */ +#define OCI_DURATION_STATEMENT (OCIDuration)(OCI_DURATION_BEGIN+3) + +/* This is to be used only during callouts. It is similar to that +of OCI_DURATION_CALL, but lasts only for the duration of a callout. +Its heap is from PGA */ +#define OCI_DURATION_CALLOUT (OCIDuration)(OCI_DURATION_BEGIN+4) + +#define OCI_DURATION_LAST OCI_DURATION_CALLOUT + /* last of predefined durations */ + +/* This is not being treated as other predefined durations such as + SESSION, CALL etc, because this would not have an entry in the duration + table and its functionality is primitive such that only allocate, free, + resize memory are allowed, but one cannot create subduration out of this +*/ +#define OCI_DURATION_PROCESS (OCIDuration)(OCI_DURATION_BEGIN-5) + +/* + * OCIDuration - OCI object duration + * + * A client can specify the duration of which an object is pinned (pin + * duration) and the duration of which the object is in memory (allocation + * duration). If the objects are still pinned at the end of the pin duration, + * the object cache manager will automatically unpin the objects for the + * client. If the objects still exist at the end of the allocation duration, + * the object cache manager will automatically free the objects for the client. + * + * Objects that are pinned with the option OCI_DURATION_TRANS will get unpinned + * automatically at the end of the current transaction. + * + * Objects that are pinned with the option OCI_DURATION_SESSION will get + * unpinned automatically at the end of the current session (connection). + * + * The option OCI_DURATION_NULL is used when the client does not want to set + * the pin duration. If the object is already loaded into the cache, then the + * pin duration will remain the same. If the object is not yet loaded, the + * pin duration of the object will be set to OCI_DURATION_DEFAULT. + */ + +/*----------------------------- OBJECT PROPERTY -----------------------------*/ + +/****************************************************************************** +** DO NOT USE OCIObjectProperty. IT IS UNSUPPORTED ** +** WILL BE REMOVED/CHANGED IN A FUTURE RELEASE ** +******************************************************************************/ +enum OCIObjectProperty +{ + /* 0 = uninitialized */ + OCI_OBJECTPROP_DIRTIED = 1, /* dirty objects */ + OCI_OBJECTPROP_LOADED, /* objects loaded in the transaction */ + OCI_OBJECTPROP_LOCKED /* locked objects */ +}; +typedef enum OCIObjectProperty OCIObjectProperty; +/* + * OCIObjectProperty -- OCI Object Property + * This specifies the properties of objects in the object cache. + */ + +/*------------------------- CACHE REFRESH OPTION ---------------------------*/ + +enum OCIRefreshOpt +{ + /* 0 = uninitialized */ + OCI_REFRESH_LOADED = 1 /* refresh objects loaded in the transaction */ +}; +typedef enum OCIRefreshOpt OCIRefreshOpt; +/* + * OCIRefreshOpt - OCI cache Refresh Option + * This option is used to specify the set of objects to be refreshed. + * + * OCI_REFRESH_LOAD refreshes the objects that are loaded in the current + * transaction. + */ + +/*-------------------------------- OBJECT EVENT -----------------------------*/ + +/****************************************************************************** +** DO NOT USE OCIObjectEvent. IT IS UNSUPPORTED ** +** WILL BE REMOVED/CHANGED IN A FUTURE RELEASE ** +******************************************************************************/ +enum OCIObjectEvent +{ + /* 0 = uninitialized */ + OCI_OBJECTEVENT_BEFORE_FLUSH = 1, /* before flushing the cache */ + OCI_OBJECTEVENT_AFTER_FLUSH, /* after flushing the cache */ + OCI_OBJECTEVENT_BEFORE_REFRESH, /* before refreshing the cache */ + OCI_OBJECTEVENT_AFTER_REFRESH, /* after refreshing the cache */ + OCI_OBJECTEVENT_WHEN_MARK_UPDATED, /* when an object is marked updated */ + OCI_OBJECTEVENT_WHEN_MARK_DELETED, /* when an object is marked deleted */ + OCI_OBJECTEVENT_WHEN_UNMARK, /* when an object is being unmarked */ + OCI_OBJECTEVENT_WHEN_LOCK /* when an object is being locked */ +}; +typedef enum OCIObjectEvent OCIObjectEvent; +/* + * OCIObjectEvent -- OCI Object Event + * This specifies the kind of event that is supported by the object + * cache. The program can register a callback that is invoked when the + * specified event occurs. + */ + +/*----------------------------- OBJECT COPY OPTION --------------------------*/ +#define OCI_OBJECTCOPY_NOREF (ub1)0x01 +/* + * OCIObjectCopyFlag - Object copy flag + * + * If OCI_OBJECTCOPY_NOREF is specified when copying an instance, the + * reference and lob will not be copied to the target instance. + */ + +/*----------------------------- OBJECT FREE OPTION --------------------------*/ +#define OCI_OBJECTFREE_FORCE (ub2)0x0001 +#define OCI_OBJECTFREE_NONULL (ub2)0x0002 +#define OCI_OBJECTFREE_HEADER (ub2)0x0004 +/* + * OCIObjectFreeFlag - Object free flag + * + * If OCI_OBJECTCOPY_FORCE is specified when freeing an instance, the instance + * is freed regardless it is pinned or diritied. + * If OCI_OBJECTCOPY_NONULL is specified when freeing an instance, the null + * structure is not freed. + */ + +/*----------------------- OBJECT PROPERTY ID -------------------------------*/ + +typedef ub1 OCIObjectPropId; +#define OCI_OBJECTPROP_LIFETIME 1 /* persistent or transient or value */ +#define OCI_OBJECTPROP_SCHEMA 2 /* schema name of table containing object */ +#define OCI_OBJECTPROP_TABLE 3 /* table name of table containing object */ +#define OCI_OBJECTPROP_PIN_DURATION 4 /* pin duartion of object */ +#define OCI_OBJECTPROP_ALLOC_DURATION 5 /* alloc duartion of object */ +#define OCI_OBJECTPROP_LOCK 6 /* lock status of object */ +#define OCI_OBJECTPROP_MARKSTATUS 7 /* mark status of object */ +#define OCI_OBJECTPROP_VIEW 8 /* is object a view object or not? */ + +/* + * OCIObjectPropId - OCI Object Property Id + * Identifies the different properties of objects. + */ + +/*----------------------- OBJECT LIFETIME ----------------------------------*/ + +enum OCIObjectLifetime +{ + /* 0 = uninitialized */ + OCI_OBJECT_PERSISTENT = 1, /* persistent object */ + OCI_OBJECT_TRANSIENT, /* transient object */ + OCI_OBJECT_VALUE /* value object */ +}; +typedef enum OCIObjectLifetime OCIObjectLifetime; +/* + * OCIObjectLifetime - OCI Object Lifetime + * Classifies objects depending upon the lifetime and referenceability + * of the object. + */ + +/*----------------------- OBJECT MARK STATUS -------------------------------*/ + +typedef uword OCIObjectMarkStatus; +#define OCI_OBJECT_NEW 0x0001 /* new object */ +#define OCI_OBJECT_DELETED 0x0002 /* object marked deleted */ +#define OCI_OBJECT_UPDATED 0x0004 /* object marked updated */ +/* + * OCIObjectMarkStatus - OCI Object Mark Status + * Status of the object - new or updated or deleted + */ + +/* macros to test the object mark status */ +#define OCI_OBJECT_IS_UPDATED(flag) bit((flag), OCI_OBJECT_UPDATED) +#define OCI_OBJECT_IS_DELETED(flag) bit((flag), OCI_OBJECT_DELETED) +#define OCI_OBJECT_IS_NEW(flag) bit((flag), OCI_OBJECT_NEW) +#define OCI_OBJECT_IS_DIRTY(flag) \ + bit((flag), OCI_OBJECT_UPDATED|OCI_OBJECT_NEW|OCI_OBJECT_DELETED) + +/*---------------------------------------------------------------------------*/ +/* TYPE MANAGER */ +/*---------------------------------------------------------------------------*/ + +/*------------------------------ TYPE CODE ----------------------------------*/ + +/* + * Type manager typecodes + * + * These are typecodes designed to be used with the type manager; + * they also include longer, more readable versions of existing SQLT names. + * Those types that are directly related to existing SQLT types are #define'd + * to their SQLT equivalents. + * + * The type manager typecodes are designed to be useable for all OCI calls. + * They are in the range from 192 to 320 for typecodes, so as not to conflict + * with existing OCI SQLT typecodes (see ocidfn.h). + */ + +#define OCI_TYPECODE_REF SQLT_REF /* SQL/OTS OBJECT REFERENCE */ +#define OCI_TYPECODE_DATE SQLT_DAT /* SQL DATE OTS DATE */ +#define OCI_TYPECODE_SIGNED8 27 /* SQL SIGNED INTEGER(8) OTS SINT8 */ +#define OCI_TYPECODE_SIGNED16 28 /* SQL SIGNED INTEGER(16) OTS SINT16 */ +#define OCI_TYPECODE_SIGNED32 29 /* SQL SIGNED INTEGER(32) OTS SINT32 */ +#define OCI_TYPECODE_REAL 21 /* SQL REAL OTS SQL_REAL */ +#define OCI_TYPECODE_DOUBLE 22 /* SQL DOUBLE PRECISION OTS SQL_DOUBLE */ +#define OCI_TYPECODE_BFLOAT SQLT_IBFLOAT /* Binary float */ +#define OCI_TYPECODE_BDOUBLE SQLT_IBDOUBLE /* Binary double */ +#define OCI_TYPECODE_FLOAT SQLT_FLT /* SQL FLOAT(P) OTS FLOAT(P) */ +#define OCI_TYPECODE_NUMBER SQLT_NUM/* SQL NUMBER(P S) OTS NUMBER(P S) */ +#define OCI_TYPECODE_DECIMAL SQLT_PDN + /* SQL DECIMAL(P S) OTS DECIMAL(P S) */ +#define OCI_TYPECODE_UNSIGNED8 SQLT_BIN + /* SQL UNSIGNED INTEGER(8) OTS UINT8 */ +#define OCI_TYPECODE_UNSIGNED16 25 /* SQL UNSIGNED INTEGER(16) OTS UINT16 */ +#define OCI_TYPECODE_UNSIGNED32 26 /* SQL UNSIGNED INTEGER(32) OTS UINT32 */ +#define OCI_TYPECODE_OCTET 245 /* SQL ??? OTS OCTET */ +#define OCI_TYPECODE_SMALLINT 246 /* SQL SMALLINT OTS SMALLINT */ +#define OCI_TYPECODE_INTEGER SQLT_INT /* SQL INTEGER OTS INTEGER */ +#define OCI_TYPECODE_RAW SQLT_LVB /* SQL RAW(N) OTS RAW(N) */ +#define OCI_TYPECODE_PTR 32 /* SQL POINTER OTS POINTER */ +#define OCI_TYPECODE_VARCHAR2 SQLT_VCS + /* SQL VARCHAR2(N) OTS SQL_VARCHAR2(N) */ +#define OCI_TYPECODE_CHAR SQLT_AFC /* SQL CHAR(N) OTS SQL_CHAR(N) */ +#define OCI_TYPECODE_VARCHAR SQLT_CHR + /* SQL VARCHAR(N) OTS SQL_VARCHAR(N) */ +#define OCI_TYPECODE_MLSLABEL SQLT_LAB /* OTS MLSLABEL */ +#define OCI_TYPECODE_VARRAY 247 /* SQL VARRAY OTS PAGED VARRAY */ +#define OCI_TYPECODE_TABLE 248 /* SQL TABLE OTS MULTISET */ +#define OCI_TYPECODE_OBJECT SQLT_NTY /* SQL/OTS NAMED OBJECT TYPE */ +#define OCI_TYPECODE_OPAQUE 58 /* SQL/OTS Opaque Types */ +#define OCI_TYPECODE_NAMEDCOLLECTION SQLT_NCO + /* SQL/OTS NAMED COLLECTION TYPE */ +#define OCI_TYPECODE_BLOB SQLT_BLOB /* SQL/OTS BINARY LARGE OBJECT */ +#define OCI_TYPECODE_BFILE SQLT_BFILE /* SQL/OTS BINARY FILE OBJECT */ +#define OCI_TYPECODE_CLOB SQLT_CLOB /* SQL/OTS CHARACTER LARGE OBJECT */ +#define OCI_TYPECODE_CFILE SQLT_CFILE /* SQL/OTS CHARACTER FILE OBJECT */ + +/* the following are ANSI datetime datatypes added in 8.1 */ +#define OCI_TYPECODE_TIME SQLT_TIME /* SQL/OTS TIME */ +#define OCI_TYPECODE_TIME_TZ SQLT_TIME_TZ /* SQL/OTS TIME_TZ */ +#define OCI_TYPECODE_TIMESTAMP SQLT_TIMESTAMP /* SQL/OTS TIMESTAMP */ +#define OCI_TYPECODE_TIMESTAMP_TZ SQLT_TIMESTAMP_TZ /* SQL/OTS TIMESTAMP_TZ */ + +#define OCI_TYPECODE_TIMESTAMP_LTZ SQLT_TIMESTAMP_LTZ /* TIMESTAMP_LTZ */ + +#define OCI_TYPECODE_INTERVAL_YM SQLT_INTERVAL_YM /* SQL/OTS INTRVL YR-MON */ +#define OCI_TYPECODE_INTERVAL_DS SQLT_INTERVAL_DS /* SQL/OTS INTRVL DAY-SEC */ +#define OCI_TYPECODE_UROWID SQLT_RDD /* Urowid type */ + + +#define OCI_TYPECODE_OTMFIRST 228 /* first Open Type Manager typecode */ +#define OCI_TYPECODE_OTMLAST 320 /* last OTM typecode */ +#define OCI_TYPECODE_SYSFIRST 228 /* first OTM system type (internal) */ +#define OCI_TYPECODE_SYSLAST 235 /* last OTM system type (internal) */ +#define OCI_TYPECODE_PLS_INTEGER 266 /* type code for PLS_INTEGER */ + +/* the following are PL/SQL-only internal. They should not be used */ +#define OCI_TYPECODE_ITABLE SQLT_TAB /* PLSQL indexed table */ +#define OCI_TYPECODE_RECORD SQLT_REC /* PLSQL record */ +#define OCI_TYPECODE_BOOLEAN SQLT_BOL /* PLSQL boolean */ + +/* NOTE : The following NCHAR related codes are just short forms for saying + OCI_TYPECODE_VARCHAR2 with a charset form of SQLCS_NCHAR. These codes are + intended for use in the OCIAnyData API only and nowhere else. */ +#define OCI_TYPECODE_NCHAR 286 +#define OCI_TYPECODE_NVARCHAR2 287 +#define OCI_TYPECODE_NCLOB 288 + + +/* To indicate absence of typecode being specified */ +#define OCI_TYPECODE_NONE 0 +/* To indicate error has to be taken from error handle - reserved for + sqlplus use */ +#define OCI_TYPECODE_ERRHP 283 + +/* The OCITypeCode type is interchangeable with the existing SQLT type + which is a ub2 */ +typedef ub2 OCITypeCode; + + +/*----------------------- GET OPTIONS FOR TDO ------------------------------*/ + +enum OCITypeGetOpt +{ + OCI_TYPEGET_HEADER, + /* load only the header portion of the TDO when getting type */ + OCI_TYPEGET_ALL /* load all attribute and method descriptors as well */ +}; +typedef enum OCITypeGetOpt OCITypeGetOpt; + +/* + * OCITypeGetOpt + * + * This is the flag passed to OCIGetTypeArray() to indicate how the TDO is + * going to be loaded into the object cache. + * OCI_TYPEGET_HEADER implies that only the header portion is to be loaded + * initially, with the rest loaded in on a 'lazy' basis. Only the header is + * needed for PL/SQL and OCI operations. OCI_TYPEGET_ALL implies that ALL + * the attributes and methods belonging to a TDO will be loaded into the + * object cache in one round trip. Hence it will take much longer to execute, + * but will ensure that no more loading needs to be done when pinning ADOs + * etc. This is only needed if your code needs to examine and manipulate + * attribute and method information. + * + * The default is OCI_TYPEGET_HEADER. + */ + + +/*------------------------ TYPE ENCAPSULTATION LEVEL ------------------------*/ + +enum OCITypeEncap +{ + /* 0 = uninitialized */ + OCI_TYPEENCAP_PRIVATE, /* private: only internally visible */ + OCI_TYPEENCAP_PUBLIC /* public: visible to both internally and externally */ +}; +typedef enum OCITypeEncap OCITypeEncap; +/* + * OCITypeEncap - OCI Encapsulation Level + */ + + +/*---------------------------- TYPE METHOD FLAGS ----------------------------*/ + +enum OCITypeMethodFlag +{ + OCI_TYPEMETHOD_INLINE = 0x0001, /* inline */ + OCI_TYPEMETHOD_CONSTANT = 0x0002, /* constant */ + OCI_TYPEMETHOD_VIRTUAL = 0x0004, /* virtual */ + OCI_TYPEMETHOD_CONSTRUCTOR = 0x0008, /* constructor */ + OCI_TYPEMETHOD_DESTRUCTOR = 0x0010, /* destructor */ + OCI_TYPEMETHOD_OPERATOR = 0x0020, /* operator */ + OCI_TYPEMETHOD_SELFISH = 0x0040, /* selfish method (generic otherwise) */ + + OCI_TYPEMETHOD_MAP = 0x0080, /* map (relative ordering) */ + OCI_TYPEMETHOD_ORDER = 0x0100, /* order (relative ordering) */ + /* OCI_TYPEMETHOD_MAP and OCI_TYPEMETHOD_ORDER are mutually exclusive */ + + OCI_TYPEMETHOD_RNDS= 0x0200, /* Read no Data State (default) */ + OCI_TYPEMETHOD_WNDS= 0x0400, /* Write no Data State */ + OCI_TYPEMETHOD_RNPS= 0x0800, /* Read no Process State */ + OCI_TYPEMETHOD_WNPS= 0x1000, /* Write no Process State */ + OCI_TYPEMETHOD_ABSTRACT = 0x2000, /* abstract (not instantiable) method */ + OCI_TYPEMETHOD_OVERRIDING = 0x4000, /* overriding method */ + OCI_TYPEMETHOD_PIPELINED = 0x8000 /* method is pipelined */ +}; +typedef enum OCITypeMethodFlag OCITypeMethodFlag; + +/* macros to test the type method flags */ +#define OCI_METHOD_IS_INLINE(flag) bit((flag), OCI_TYPEMETHOD_INLINE) +#define OCI_METHOD_IS_CONSTANT(flag) bit((flag), OCI_TYPEMETHOD_CONSTANT) +#define OCI_METHOD_IS_VIRTUAL(flag) bit((flag), OCI_TYPEMETHOD_VIRTUAL) +#define OCI_METHOD_IS_CONSTRUCTOR(flag) bit((flag), OCI_TYPEMETHOD_CONSTRUCTOR) +#define OCI_METHOD_IS_DESTRUCTOR(flag) bit((flag), OCI_TYPEMETHOD_DESTRUCTOR) +#define OCI_METHOD_IS_OPERATOR(flag) bit((flag), OCI_TYPEMETHOD_OPERATOR) +#define OCI_METHOD_IS_SELFISH(flag) bit((flag), OCI_TYPEMETHOD_SELFISH) +#define OCI_METHOD_IS_MAP(flag) bit((flag), OCI_TYPEMETHOD_MAP) +#define OCI_METHOD_IS_ORDER(flag) bit((flag), OCI_TYPEMETHOD_ORDER) +#define OCI_METHOD_IS_RNDS(flag) bit((flag), OCI_TYPEMETHOD_RNDS) +#define OCI_METHOD_IS_WNDS(flag) bit((flag), OCI_TYPEMETHOD_WNDS) +#define OCI_METHOD_IS_RNPS(flag) bit((flag), OCI_TYPEMETHOD_RNPS) +#define OCI_METHOD_IS_WNPS(flag) bit((flag), OCI_TYPEMETHOD_WNPS) +#define OCI_METHOD_IS_ABSTRACT(flag) bit((flag), OCI_TYPEMETHOD_ABSTRACT) +#define OCI_METHOD_IS_OVERRIDING(flag) bit((flag), OCI_TYPEMETHOD_OVERRIDING) +#define OCI_METHOD_IS_PIPELINED(flag) bit((flag), OCI_TYPEMETHOD_PIPELINED) + +#define OCI_TYPEMETHOD_IS_INLINE(flag) bit((flag), OCI_TYPEMETHOD_INLINE) +#define OCI_TYPEMETHOD_IS_CONSTANT(flag) bit((flag), OCI_TYPEMETHOD_CONSTANT) +#define OCI_TYPEMETHOD_IS_VIRTUAL(flag) bit((flag), OCI_TYPEMETHOD_VIRTUAL) +#define OCI_TYPEMETHOD_IS_CONSTRUCTOR(flag) \ + bit((flag), OCI_TYPEMETHOD_CONSTRUCTOR) +#define OCI_TYPEMETHOD_IS_DESTRUCTOR(flag) \ + bit((flag), OCI_TYPEMETHOD_DESTRUCTOR) +#define OCI_TYPEMETHOD_IS_OPERATOR(flag) bit((flag), OCI_TYPEMETHOD_OPERATOR) +#define OCI_TYPEMETHOD_IS_SELFISH(flag) bit((flag), OCI_TYPEMETHOD_SELFISH) +#define OCI_TYPEMETHOD_IS_MAP(flag) bit((flag), OCI_TYPEMETHOD_MAP) +#define OCI_TYPEMETHOD_IS_ORDER(flag) bit((flag), OCI_TYPEMETHOD_ORDER) +#define OCI_TYPEMETHOD_IS_RNDS(flag) bit((flag), OCI_TYPEMETHOD_RNDS) +#define OCI_TYPEMETHOD_IS_WNDS(flag) bit((flag), OCI_TYPEMETHOD_WNDS) +#define OCI_TYPEMETHOD_IS_RNPS(flag) bit((flag), OCI_TYPEMETHOD_RNPS) +#define OCI_TYPEMETHOD_IS_WNPS(flag) bit((flag), OCI_TYPEMETHOD_WNPS) +#define OCI_TYPEMETHOD_IS_ABSTRACT(flag) bit((flag), OCI_TYPEMETHOD_ABSTRACT) +#define OCI_TYPEMETHOD_IS_OVERRIDING(flag) \ + bit((flag), OCI_TYPEMETHOD_OVERRIDING) +#define OCI_TYPEMETHOD_IS_PIPELINED(flag) bit((flag), OCI_TYPEMETHOD_PIPELINED) + +/* macros to set the type method flags */ +#define OCI_TYPEMETHOD_SET_INLINE(flag) bis((flag), OCI_TYPEMETHOD_INLINE) +#define OCI_TYPEMETHOD_SET_CONSTANT(flag) bis((flag), OCI_TYPEMETHOD_CONSTANT) +#define OCI_TYPEMETHOD_SET_VIRTUAL(flag) bis((flag), OCI_TYPEMETHOD_VIRTUAL) +#define OCI_TYPEMETHOD_SET_CONSTRUCTOR(flag) \ + bis((flag), OCI_TYPEMETHOD_CONSTRUCTOR) +#define OCI_TYPEMETHOD_SET_DESTRUCTOR(flag) \ + bis((flag), OCI_TYPEMETHOD_DESTRUCTOR) +#define OCI_TYPEMETHOD_SET_OPERATOR(flag) bis((flag), OCI_TYPEMETHOD_OPERATOR) +#define OCI_TYPEMETHOD_SET_SELFISH(flag) bis((flag), OCI_TYPEMETHOD_SELFISH) +#define OCI_TYPEMETHOD_SET_MAP(flag) bis((flag), OCI_TYPEMETHOD_MAP) +#define OCI_TYPEMETHOD_SET_ORDER(flag) bis((flag), OCI_TYPEMETHOD_ORDER) +#define OCI_TYPEMETHOD_SET_RNDS(flag) bis((flag), OCI_TYPEMETHOD_RNDS) +#define OCI_TYPEMETHOD_SET_WNDS(flag) bis((flag), OCI_TYPEMETHOD_WNDS) +#define OCI_TYPEMETHOD_SET_RNPS(flag) bis((flag), OCI_TYPEMETHOD_RNPS) +#define OCI_TYPEMETHOD_SET_WNPS(flag) bis((flag), OCI_TYPEMETHOD_WNPS) + +/* macros to clear the type method flags */ +#define OCI_TYPEMETHOD_CLEAR_INLINE(flag) bic((flag), OCI_TYPEMETHOD_INLINE) +#define OCI_TYPEMETHOD_CLEAR_CONSTANT(flag) \ + bic((flag), OCI_TYPEMETHOD_CONSTANT) +#define OCI_TYPEMETHOD_CLEAR_VIRTUAL(flag) bic((flag), OCI_TYPEMETHOD_VIRTUAL) +#define OCI_TYPEMETHOD_CLEAR_CONSTRUCTOR(flag) \ + bic((flag), OCI_TYPEMETHOD_CONSTRUCTOR) +#define OCI_TYPEMETHOD_CLEAR_DESTRUCTOR(flag) \ + bic((flag), OCI_TYPEMETHOD_DESTRUCTOR) +#define OCI_TYPEMETHOD_CLEAR_OPERATOR(flag) \ + bic((flag), OCI_TYPEMETHOD_OPERATOR) +#define OCI_TYPEMETHOD_CLEAR_SELFISH(flag) bic((flag), OCI_TYPEMETHOD_SELFISH) +#define OCI_TYPEMETHOD_CLEAR_MAP(flag) bic((flag), OCI_TYPEMETHOD_MAP) +#define OCI_TYPEMETHOD_CLEAR_ORDER(flag) bic((flag), OCI_TYPEMETHOD_ORDER) +#define OCI_TYPEMETHOD_CLEAR_RNDS(flag) bic((flag), OCI_TYPEMETHOD_RNDS) +#define OCI_TYPEMETHOD_CLEAR_WNDS(flag) bic((flag), OCI_TYPEMETHOD_WNDS) +#define OCI_TYPEMETHOD_CLEAR_RNPS(flag) bic((flag), OCI_TYPEMETHOD_RNPS) +#define OCI_TYPEMETHOD_CLEAR_WNPS(flag) bic((flag), OCI_TYPEMETHOD_WNPS) + +/*--------------------------- TYPE PARAMETER MODE ---------------------------*/ + +enum OCITypeParamMode +{ + /* PL/SQL starts this from 0 */ + OCI_TYPEPARAM_IN = 0, /* in */ + OCI_TYPEPARAM_OUT, /* out */ + OCI_TYPEPARAM_INOUT, /* in-out */ + OCI_TYPEPARAM_BYREF, /* call by reference (implicitly in-out) */ + OCI_TYPEPARAM_OUTNCPY, /* OUT with NOCOPY modifier */ + OCI_TYPEPARAM_INOUTNCPY /* IN OUT with NOCOPY modifier */ +}; +typedef enum OCITypeParamMode OCITypeParamMode; + + +/*-------------------------------- DEFAULTS ---------------------------------*/ + +/* default binary and decimal precision and scale */ + +#define OCI_NUMBER_DEFAULTPREC ((ub1)0) /* no precision specified */ +#define OCI_NUMBER_DEFAULTSCALE ((sb1)MAXSB1MINVAL) + /* no binary/decimal scale specified */ + +/* default maximum length for varrays and vstrings (used in sql.bsq) */ + +#define OCI_VARRAY_MAXSIZE 4000 + /* default maximum number of elements for a varray */ +#define OCI_STRING_MAXLEN 4000 /* default maximum length of a vstring */ + +/*---------------------------------------------------------------------------*/ +/* This set of macro is used only in beta2. They should be removed as soon as + * PLSQL has made the changes of not using these macros. + */ + +/* Special duration for allocating memory only. No instance can be allocated + * given these durations. + */ +#define OCICoherency OCIRefreshOpt +#define OCI_COHERENCY_NONE (OCIRefreshOpt)2 +#define OCI_COHERENCY_NULL (OCIRefreshOpt)4 +#define OCI_COHERENCY_ALWAYS (OCIRefreshOpt)5 + +#endif /* ORO_ORACLE */ + diff --git a/OCI/include/ort.h b/OCI/include/ort.h new file mode 100644 index 0000000..9562f2e --- /dev/null +++ b/OCI/include/ort.h @@ -0,0 +1,2594 @@ +/* @(#)ort.h 1.44 95/07/07 */ + +/* Copyright (c) 1994, 2005, Oracle. All rights reserved. */ + +/* + NAME + + ORT - ORacle's external open Type interface to the open type manager (OTM) + + DESCRIPTION + + The open type manager interface includes dynamic type operations to + create, delete, update, and access types. See the "Functional + Specification for Oracle Object Call Interface (Objects Project), + Version 1.0" for a user level description of the OTM. For a more + detailed description, see the "Component Document for the Open Type + Manager, Version 1.0". + + NOTE: MOST Of the functions in this header file are being desupported. + Please use the OCIDescribeAny interface as described in oci.h + instead. + The OCIType, OCITypeElem, OCITypeMethod abstract types continue + to be supported. The only two functions that remain to be documented + are OCITypeArrayByName and OCITypeArrayByRef. + All obsolete types/functions are marked accordingly below. + + RELATED DOCUMENTS + + For the functional specification for the OTM, see: + [1] Kotsovolos, Susan, "Functional Specification for Oracle Object + Call Interface (Objects Project), Version 1.0", Oracle + Corporation, February 1995. + For the internal design of the OTM, see the following: + [2] Kotsovolos, Susan, "Component Document for the Open Type Manager", + Oracle Corporation, November 1994. + [3] Kotsovolos, Susan, "Design for The Open Type Manager, Oracle + Object Management Subsystem Version 1.0", Oracle Corporation, + March 1994. + [4] Kotsovolos, Susan and Tin A. Nguyen, "The Open Type Manager", + Oracle Corporation, March 1994. + [5] Kotsovolos, Susan and Tin A. Nguyen, "Schema Evolution", + Oracle Corporation, March 1994. + For a description of the types the OTM must support, see: + [6] Nguyen, Tin A., "The Open Type System", Oracle Corporation, + February 1994. + + INSPECTION STATUS + + Inspection date: + Inspection status: + Estimated increasing cost defects per page: + Rule sets: + + ACCEPTANCE REVIEW STATUS + + Review date: + Review status: + Reviewers: + + + **** ALL OBSOLETE FUNCTIONS/TYPES ARE MARKED ACCORDINGLY *** + + EXPORT FUNCTIONS + + None + + PUBLIC DATA STRUCTURES + + OCIType - type descriptor in the object cache + OCITypeElem - type element descriptor in the object cache + (used for attributes and paramters) + OCITypeCode - Open Type System type code. + OCITypeMethod - method descriptor in the object cache + OCITypeParamMode - parameter modes (ie. IN, IN-OUT etc) + + PUBLIC FUNCTIONS + + ITERATOR (for OCITypeAttrNext and OCITypeMethodNext) + + OCITypeIterNew - ** OBSOLETE ** Create new instance of an iteraton. + OCITypeIterSet - ** OBSOLETE ** Initialize iterator. + OCITypeIterFree - ** OBSOLETE ** Free instance of iterator. + + TYPE GET + + OCITypeByName - ** OBSOLETE ** Get a type by name. + OCITypeArrayByName - Get an array of types by their names. + OCITypeByRef - ** OBSOLETE ** Get a type by its CREF. + OCITypeArrayByRef - Get an array of types by their CREFs. + + TYPE ACCESSORS + + OCITypeName - ** OBSOLETE ** OCI Get a type's name. + OCITypeSchema - ** OBSOLETE ** OCI Get a type's schema name. + OCITypeTypeCode - ** OBSOLETE ** OCI Get a type's type code. + OCITypeVersion - ** OBSOLETE ** OCI Get a Type's user-readable Version. + OCITypeAttrs - ** OBSOLETE ** OCI Get a Type's Number of Attributes. + OCITypeMethods - ** OBSOLETE ** OCI Get a Type's Number of Methods. + + TYPE ELEMENT ACCESSORS (they represent attributes/parameters/results) + + OCITypeElemName - ** OBSOLETE ** Get a type element's (only for + attributes) name. + OCITypeElemType - ** OBSOLETE ** Get a type element's type + descriptor. + OCITypeElemTypeCode - ** OBSOLETE ** Get a type element's typecode. + OCITypeElemParameterizedType - ** OBSOLETE ** Get a type element's + parameterized type's type descriptor. + OCITypeElemNumPrec - ** OBSOLETE ** Get a number's precision. + OCITypeElemNumScale - ** OBSOLETE ** Get a decimal or oracle Number's + Scale + OCITypeElemCharSetID - ** OBSOLETE ** Get a fixed or variable length + string's character set ID. + OCITypeElemCharSetForm - ** OBSOLETE ** Get a fixed or variable length + string's character set form (how + character set information has + been specified). + OCITypeElemLength - ** OBSOLETE ** Get a raw, fixed or variable + length string's length. + OCITypeElemParamMode - ** OBSOLETE ** Get element's parameter's mode + (only valid for parameter). + OCITypeElemDefaultValue - ** OBSOLETE ** Get element's Default Value. + + ATTRIBUTE ACCESSORS + + OCITypeAttrByName - ** OBSOLETE ** Get an Attribute by Name. + OCITypeAttrNext - ** OBSOLETE ** Get an Attribute by Iteration. + + COLLECTION ACCESSORS + + OCITypeCollTypeCode - ** OBSOLETE ** Get a named collection's typecode. + OCITypeCollElem - ** OBSOLETE ** Get a named collection's element's + type element information. + OCITypeCollSize - ** OBSOLETE ** Get a named collection's size in + number of elements. + + METHOD ACCESSORS + + OCITypeMethodOverload - ** OBSOLETE ** Get number of overloaded methods + with the given method name. + (no direct equivalent for + OCIDescribe interface) + OCITypeMethodByName - ** OBSOLETE ** Get one or more methods by name. + OCITypeMethodNext - ** OBSOLETE ** Iterate to the next method to + retrieve. + OCITypeMethodName - ** OBSOLETE ** Get method's name. + OCITypeMethodEncap - ** OBSOLETE ** Get method's encapsulation level. + OCITypeMethodFlags - ** OBSOLETE ** et method's flags. + OCITypeMethodMap - ** OBSOLETE ** Get type's map function. + OCITypeMethodOrder - ** OBSOLETE ** Get type's order function. + OCITypeMethodParams - ** OBSOLETE ** Get a method's number of + parameters. + + RESULT ACCESSORS + + OCITypeResult - ** OBSOLETE ** OCI Get a method's Result. + + See also ATTRIBUTE/PARAMETER/RESULT TYPE ACCESSORS. + + PARAMETER ACCESSORS + + OCITypeParamByPos - ** OBSOLETE ** Get a Parameter in a method By + Position. + OCITypeParamByName - ** OBSOLETE ** Get a Parameter in a method By Name. + OCITypeParamPos - ** OBSOLETE ** Get a Parameter's PoSition in a + method. + + CALL GRAPHS: + + Only type accessors are supported for 8.0. + ** OBSOLETE ** please use OCIDescribe interface + + TYPE ACCESSOR EXAMPLE + + CREATE TYPE CAR + ( + name vstring, + age number, + number car_age; /o Oracle number o/ + weight car_weight; /o abstract type o/ + + PUBLIC: + + /o methods o/ + car(orlvs a_name, number an_age, WEIGHT a_weight); + ~car(); + inline number get_age() const; + + /o relative ordering (map) functions o/ + number car_map + ); + + /o the following code accesses the type created above o/ + + ub1 meth_flags; + ub4 i, j; + ub4 text_len, position; + ub4 count; + ub4 length; + OCITypeCode typecode; + OCIRef *attr_ref; + OCIRef *param_ref; + OCIType *tdo, new_tdo, final_tdo; + OCITypeElem *elem; + OCITypeIter *iterator_ort; + oratext (*names)[]; + ub4 lengths[]; + ub4 *positions; + oratext *name; + oratext name_buffer[M_IDEN]; + + /o initialize the references o/ + DISCARD orlrini(env, err, (dvoid *)&attr_ref); + DISCARD orlrini(env, err, (dvoid *)¶m_ref); + + /o ----------------- GET INFORMATION ABOUT A TYPE ----------------- o/ + + /o start a transaction o/ + + /o Pin the type until the end of the transaction. Pinning the type is + o required before using any type accessors. + o/ + if (OCITypeByName(env, err, svc, (oratext *)0, 0, "CAR", strlen("CAR"), + OCI_DURATION_TRANS, &car_ref, &car_tdo) != OCI_SUCCESS) + /o error o/ ; + + /o get the type's name o/ + if (!memcmp(OCITypeName(env, err, car_tdo, &text_len), "person", + text_len)) + /o do something o/ ; + + /o get the type's schema name o/ + if (!memcmp(OCITypeSchema(env, err, car_tdo, &text_len), "john", + text_len)) + /o do something o/ ; + + /o get the type code of the type o/ + if (OCITypeTypeCode(env, err, car_tdo) == OCI_TYPECODE_ADT) + /o do something o/ ; + + /o get the type version o/ + if (!memcmp(OCITypeVersion(env, err, car_tdo, &text_len), "1", text_len)) + /o do something o/ ; + + /o ------- GET FLATTENED POSITION OF AN ATTRIBUTES IN A TYPE ------- o/ + + names = malloc(sizeof(oratext *) * 2); + names[0] = malloc(strlen("car_weight")); + names[1] = malloc(strlen("ounces")); + memcpy(names[0], "car_weight", strlen("car_weight")); + memcpy(names[1], "ounces", strlen("ounces")); + + lengths = malloc(sizeof(ub4) * 2); + lengths[0] = strlen("car_weight"); + lengths[1] = strlen("ounces"); + + /o ---------- GET IMMEDIATE ATTRIBUTES IN A TYPE ---------- o/ + + /o loop through all attributes in the type with iterator o/ + if (OCITypeIterNew(env, err, car_tdo, &iterator_ort) != OCI_SUCCESS) + /o do something o/ + + while (OCITypeAttrNext(env, err, iterator_ort, &ado) != OCI_NO_DATA) + { + /o get the attribute's name o/ + if (!memcmp(OCITypeElemName(env, err, ado, &text_len), + "tiger", text_len)) + /o do something o/ ; + + /o get the attribute's type descriptor o/ + if (OCITypeElemType(env, err, ado, &tdo) != OCI_SUCCESS) + /o error o/ ; + + /o get the attribute's type code o/ + typecode = OCITypeElemTypeCode(env, err, ado); + + switch (typecode) + { + /o scalar types o/ + case OCI_TYPECODE_DATE: /o date o/ + case OCI_TYPECODE_SIGNED8: /o byte o/ + case OCI_TYPECODE_SIGNED16: /o short o/ + case OCI_TYPECODE_UNSIGNED8: /o unsigned byte o/ + case OCI_TYPECODE_UNSIGNED16: /o unsigned short o/ + case OCI_TYPECODE_OCTET: /o octet o/ + case OCI_TYPECODE_TABLE: /o nested table o/ + case OCI_TYPECODE_CLOB: /o character lob o/ + case OCI_TYPECODE_BLOB: /o binary lob o/ + case OCI_TYPECODE_CFILE: /o character file object o/ + case OCI_TYPECODE_BFILE: /o binary file object o/ + + /o do something o/ + break; + + /o number types o/ + case OCI_TYPECODE_NUMBER: /o oracle number o/ + case OCI_TYPECODE_DECIMAL: /o decimal o/ + { + /o get the scale of the number o/ + if (OCITypeElemNumScale(env, err, ado) == 3) + /o do something o/ ; + } + /o fall through to get the precision o/ + + case OCI_TYPECODE_FLOAT: /o float o/ + case OCI_TYPECODE_SIGNED32: /o long o/ + case OCI_TYPECODE_UNSIGNED32: /o unsigned long o/ + case OCI_TYPECODE_REAL: /o real o/ + case OCI_TYPECODE_DOUBLE: /o double o/ + { + /o get the precision of the number o/ + if (OCITypeElemNumPrec(env, err, ado) == 2) + /o do something o/ ; + } + break; + + /o string types o/ + case OCI_TYPECODE_CHAR: /o fixed length string o/ + case OCI_TYPECODE_VARCHAR2: /o variable length string o/ + case OCI_TYPECODE_RAW: /o raw o/ + { + /o get the length of the fixed or variable length string o/ + if (OCITypeElemLength(env, err, ado) < 100) + /o do something o/ + } + break; + + /o parameterized types o/ + case OCI_TYPECODE_REF: /o reference o/ + case OCI_TYPECODE_PTR: /o pointer o/ + { + /o get the type stored in the parameterized type o/ + if (OCITypeElemParameterizedType(env, err, ado, &tdo) + != OCI_SUCCESS) + /o error o/ ; + + /o do something o/ + if (OCI_TYPEELEM_IS_REF(OCITypeElemFlags(env, err, ado)))... + } + break; + + /o domain type o/ + case OCI_TYPECODE_NAMEDCOLLECTION: + switch (OCITypeCollTypeCode(env, err, tdo)) + { + case OCI_TYPECODE_VARRAY: /o variable array o/ + ub4 num_elems; + OCIType *element_type; + + /o get the number of elements in the farray or the maximum number + o of elements in the varray. + o/ + OCITypeCollSize(env, err, tdo, &num_elems); + + /o get the type of the array o/ + OCITypeElemType(env, err, tdo, &element_type); + } + break; + + case OCI_TYPECODE_TABLE: /o multiset o/ + { + OCIType *table_type; + + /o get the type of the multiset o/ + OCITypeElemType(env, err, tdo, &table_type); + + /o do something o/ + } + } + + /o abstract type o/ + case OCI_TYPECODE_ADT: /o abstract data type o/ + { + /o get the adt information o/ + if (OCITypeElemType(env, err, ado, &tdo) != OCI_SUCCESS) + /o error o/ ; + + /o do something o/ + } + break; + + default: + DISCARD printf("Error: invalid type code\n"); + + } /o end of typecode switch o/ + + } /o end of loop through all attributes in a type o/ + + + /o ------------ GET THE IMMEDIATE METHODS OF A TYPE ------------ o/ + + /o loop through all methods in the type by reusing iterator o/ + if (OCITypeIterSet(env, err, car_tdo, iterator_ort) != OCI_SUCCESS) + /o do something o/ + + while (OCITypeMethodNext(env, err, iterator_ort) != OCI_NO_DATA) + { + /o get the method's name o/ + if (!memcmp(OCITypeMethodName(env, err, mdo, &text_len), "car", + text_len)) + /o do something o/ ; + + /o get the method's encapsulation o/ + if (OCITypeMethodEncap(env, err, mdo) == OCI_TYPEENCAP_PUBLIC) + /o do something o/ ; + + /o get the method's flags o/ + meth_flags = OCITypeMethodFlags(env, err, mdo); + if (meth_flags & OCI_TYPEMETHOD_VIRTUAL) + /o do something o/ ; + + + /o ------------ GET THE PARAMETERS IN A METHOD ------------ o/ + + /o loop through all parameters in the method o/ + count = OCITypeMethodParams(env, err, mdo); + for (j = 1; j <= count; j++) + { + /o get the parameter information by position o/ + if (OCITypeParamByPos(env, err, mdo, i, &elem) != OCI_SUCCESS) + /o error o/ ; + + /o get the parameter's name o/ + if (!memcmp(OCITypeElemName(env, err, elem, &text_len), "an_age", + text_len)) + /o do something o/ ; + + /o get the parameter's mode o/ + if (OCITypeElemMode(env, err, elem) == OCI_PARAM_OUT) + /o do something o/ ; + + /o get the parameter's required flag o/ + if (ortgprq(env, err, elem)) + /o do something o/ ; + } + } + + /o get a method by name o/ + if (OCITypeMethodByName(env, err, car_tdo, "car_constructor", + strlen("car_constructor"), NULLP(OCIRef), &mdo) + != OCI_SUCCESS) + /o error o/ ; + + /o get a parameter in a method by name o/ + if (OCITypeParamByName(env, err, mdo, "an_age", strlen("an_age"), &elem) + != OCI_SUCCESS) + /o error o/ ; + + /o get a parameter's typecode o/ + typecode = OCITypeElemTypeCode(env, err, elem); + + /o get a parameter's type object o/ + if (OCITypeElemType(env, err, elem, &tdo)) != OCI_SUCCESS) + /o error o/ ; + + /o get a parameter's position in a method o/ + if (ortgpps(env, err, mdo, "an_age", strlen("an_age"), + &position, NULLP(OCIRef), NULLP(OCITypeElem)) != OCI_SUCCESS) + /o error o/ ; + + /o ------------ GET THE METHOD's RESULT ------------ o/ + + /o get a method by name o/ + if (OCITypeMethodByName(env, err, car_tdo, "get_age", strlen("get_age"), + &mdo) != OCI_SUCCESS) + /o error o/ ; + + /o get the typecode of the method's result o/ + typecode = OCITypeElemTypeCode(env, err, mdo); + + + /o ----------------- END ---------------- o/ + + /o free the references implicitly allocated o/ + DISCARD orlrfre(env, err, (dvoid *)&attr_ref); + DISCARD orlrfre(env, err, (dvoid *)¶m_ref); + + NOTES + + MODIFIED + dmukhin 06/29/05 - ANSI prototypes; miscellaneous cleanup + srseshad 03/12/03 - convert oci public api to ansi + aahluwal 06/03/02 - bug 2360115 + skabraha 04/16/02 - fix compiler warnings + rkasamse 03/02/01 - do not use iterator : keyword in MSVB + bpalaval 02/09/01 - Change text to oratext. + rxgovind 01/31/00 - add OCIType interfaces for transient types + whe 09/01/99 - 976457:check __cplusplus for C++ code + cxcheng 05/06/97 - make OCI_TYPE?? test macros return either 1 or 0 + cxcheng 04/22/97 - add comment on desupporting OCIType functions + skrishna 03/18/97 - fix ifdef for supporting ansi and k&r proto-types + cxcheng 02/26/97 - fix lint problem with oro names + cxcheng 02/06/97 - take out short name support except with SLSHORTNAME + cxcheng 01/15/97 - change prototype of OCITypeElemParameterizedType() + cxcheng 01/03/97 - replace bit in OCI_TYPEPARAM_IS_REQUIRED with bitwis + cxcheng 12/31/96 - replace OCI_PARAM_IS_REQUIRED with OCI_TYPEPARAM_IS_ + cxcheng 12/09/96 - add prototype for OCITypeElemExtTypeCode and OCIType + cxcheng 11/25/96 - add schema name parameter to OCITypeVTInsert() + cxcheng 11/20/96 - fix prototype for OCITypeByName() + cxcheng 11/11/96 - fix prototype for OCITypeByName() + cxcheng 11/05/96 - remove OCITypeElemExtTypeCode and OCITypeCollExtType + dchatter 10/28/96 - change ortgatyp to be OCITypeArrayByName + cxcheng 10/25/96 - fix problem with ortgatyp at end + cxcheng 10/22/96 - add OCITypeByRef and OCITypeArrayByRef + cxcheng 10/20/96 - remove ortgtyp() from #define section at end + cxcheng 10/18/96 - rename OCITypeGetArray to OCITypeArrayByName + cxcheng 10/17/96 - final change to prototype for OCI_TYPEPARAM_IS_REQUI + cxcheng 10/15/96 - rename OCIEncapLevel and OCIMethodFlag + cxcheng 10/14/96 - change prototype of OCITypeResult + mluong 10/11/96 - fix compile error + jwijaya 10/10/96 - fix bug on OCI_PARAM_IS_REQUIRED + cxcheng 10/09/96 - more lint and link fixes + cxcheng 10/08/96 - more lint fixes + cxcheng 10/07/96 - more changes + cxcheng 10/04/96 - replace short names with long names + cxcheng 10/01/96 - change to long names for readability + cxcheng 09/27/96 - rename ortgatyp() to ortgtya() for lint + cxcheng 09/20/96 - add ortgatyp() for array get type + cxcheng 09/18/96 - add array pin and iterator functions + cxcheng 08/09/96 - add version table calls + cxcheng 07/22/96 - add OCITypeElemType() to top + jwijaya 07/03/96 - add ANSI prototypes + cxcheng 06/28/96 - add OCITypeElemCharSetForm() + cxcheng 06/26/96 - fix comment on OCITypeParamByPos()/ortgpps() + cxcheng 06/18/96 - fix comments on OCITypeResult() + cxcheng 06/17/96 - improve comments + skrishna 06/03/96 - change OCITypeCollElem() prototype + vkrishna 05/29/96 - replace OROTCFAR with OROTCCAR + cxcheng 05/28/96 - fix comments, remove non-beta1 functions + cxcheng 05/02/96 - fix prototype bugs + cxcheng 04/29/96 - rename OCITypeElemm() to ortanct() + cxcheng 04/26/96 - add ortgrbp and ortftyi, + fix comments and examples + cxcheng 04/22/96 - big merge to main branch + cxcheng 04/17/96 - fix syntax + cxcheng 04/08/96 - change prototype to ortaty() + skrishna 04/08/96 - change ort*() to take OCIEnv* and OCIError* instead + of oroenv* + cxcheng 03/28/96 - add ortslob(), change ortsstr() prototype + cxcheng 03/13/96 - change alter type interface + cxcheng 03/11/96 - ORT interface changes + cxcheng 02/27/96 - correct comments + jboonleu 02/09/96 - rename oroopd to OCIDuration + cxcheng 01/19/96 - change ORTCTYVAL to ORTCTYEMB for embedded ADT + cxcheng 02/14/96 - add more comments + jboonleu 02/09/96 - rename oroopd to OCIDuration + cxcheng 02/07/96 - fix comments and examples + cxcheng 01/19/96 - new ORT interface without korfc's + cxcheng 01/08/96 - consolidate collection functions + cxcheng 12/14/95 - remove obsolete ortgcol() and ortrelease() + jweisz 12/12/95 - merge screwup: ortdth twice + cxcheng 12/05/95 - change multiset interface for new standard + skotsovo 12/01/95 - merge from /vobs/rdbms/public/ort.h@@/main/ + st_rdbms_big_dev/st_rdbms_obj/ + st_rdbms_jwijaya_variable_ref + cxcheng 11/13/95 - add ortaty()/orteaty() + cxcheng 11/13/95 - add new collection type accessors + skotsovo 10/30/95 - add 'oid' type b/c extent type uses it. + skotsovo 10/24/95 - update according to new variable length ref + cxcheng 10/05/95 - add null support, change prototypes to calls + cxcheng 10/03/95 - add OCITypeMethodOrder() to get ORDER method + cxcheng 09/28/95 - add OCITypeElemm() for collection types support + skotsovo 06/05/95 - add adt_type parameter to ortsab() + skotsovo 05/10/95 - ifdef'd out ortgafp() + skotsovo 03/07/95 - update interface to only include release 1 + skotsovo 02/22/95 - add multiset accessors + skotsovo 02/09/95 - update according to new ots doc + skotsovo 01/31/95 - add rest of release 1 types + skotsovo 01/24/95 - categorize sint32, double, and real as number types + (with precision and scale) instead of scalar types. + skotsovo 01/12/95 - remove dependency from ortdty interface + skotsovo 01/03/95 - remove orotyp accessors + skotsovo 12/12/94 - update comments + skotsovo 12/05/94 - change OCITypeElemParameterizedTyper interface + skotsovo 10/26/94 - add type version table + skotsovo 10/17/94 - fix ortgafp() comments + skotsovo 10/14/94 - modify ortgafp() parameters + skotsovo 10/14/94 - add examples + skotsovo 10/13/94 - add a few new routines + jwijaya 10/07/94 - add namespace to pin by name + jwijaya 10/02/94 - connection handle -> connection number + skotsovo 09/13/94 - modify example to use updated oririni interface + skotsovo 08/25/94 - change scale to sb1 from sb2 + skotsovo 07/28/94 - add ortbeg() and ortend() + skotsovo 07/14/94 - add decimal type & call graph + skotsovo 06/28/94 - subset by removing miscellaneous functions + skotsovo 06/28/94 - consistently put comments before typedefs + skotsovo 06/27/94 - modify according to new header file template, add + more examples, and change ortcty() to return a + reference to the type + skotsovo 06/24/94 - add functions to get type information from orotyp + skotsovo 06/20/94 - finish modifying according to header template + skotsovo 06/09/94 - modify according to header file template + skotsovo 06/08/94 - replace s.h with oratypes.h + skotsovo 05/24/94 - modify comments & update example + skotsovo 05/23/94 - modify fnt names for create, alter and drop type + skotsovo 05/18/94 - remove ortdme() -- delete a method + skotsovo 05/17/94 - add tdo parameter to all type modifiers + skotsovo 05/11/94 - return text* instead of including it in arglist + skotsovo 11/16/93 - creation + +*/ + +#ifndef ORATYPES +#include +#endif +#ifndef ORO_ORACLE +#include +#endif +#ifndef OCI_ORACLE +#include +#endif + +#ifndef ORT_ORACLE +#define ORT_ORACLE + +/*---------------------------------------------------------------------------*/ +/* SHORT NAMES SUPPORT SECTION */ +/*---------------------------------------------------------------------------*/ + +#ifdef SLSHORTNAME + +/* the following are short names that are only supported on IBM mainframes + with the SLSHORTNAME defined. + With this all subsequent long names will actually be substituted with + the short names here */ + +#define OCITypeArrayByName ortgatyp +#define OCITypeAttrByName ortgabn +#define OCITypeAttrNext ortgabi +#define OCITypeAttrs ortgtna +#define OCITypeByRef ortgtbrf +#define OCITypeCollElem ortgcel +#define OCITypeCollExtTypeCode ortgcsqt +#define OCITypeCollSize ortgcne +#define OCITypeCollTypeCode ortgdttc +#define OCITypeElem ortado +#define OCITypeElemCharSetForm ortgscform +#define OCITypeElemCharSetID ortgscid +#define OCITypeElemDefaultValue ortgpdv +#define OCITypeElemExtTypeCode ortgasqt +#define OCITypeElemLength ortgsl +#define OCITypeElemName ortganm +#define OCITypeElemNumPrec ortgnp +#define OCITypeElemNumScale ortgns +#define OCITypeElemParamMode ortgpmo +#define OCITypeElemParameterizedType ortgpa +#define OCITypeElemType ortgaty +#define OCITypeElemTypeCode ortgatc +#define OCITypeIter ortitr +#define OCITypeIterFree ortifre +#define OCITypeIterNew ortinew +#define OCITypeIterSet ortiset +#define OCITypeMethod ortmdo +#define OCITypeMethodByName ortgmbn +#define OCITypeMethodEncap ortgmen +#define OCITypeMethodFlags ortgmfl +#define OCITypeMethodMap ortgmmap +#define OCITypeMethodName ortgmnm +#define OCITypeMethodNext ortgmbi +#define OCITypeMethodOrder ortgmor +#define OCITypeMethodOverload ortgmno +#define OCITypeMethodParams ortgmnp +#define OCITypeMethods ortgtnm +#define OCITypeName ortgtme +#define OCITypeParamByName ortgpbn +#define OCITypeParamPos ortgpps +#define OCITypeSchema ortgtsch +#define OCITypeTypeCode ortgttc +#define OCITypeVTInit ortvini +#define OCITypeVTInsert ortvins +#define OCITypeVTSelect ortvsel +#define OCITypeVersion ortgtvn + +#endif /* SLSHORTNAME */ + + +/*============================*/ +/* PUBLIC TYPES AND CONSTANTS */ +/*============================*/ + +/*----------------------------- TYPE DESCRIPTION ----------------------------*/ + +/* + * OCIType - OCI Type Description Object + * + * The contents of an 'OCIType' is private/opaque to clients. Clients just + * need to declare and pass 'OCIType' pointers in to the type manage + * functions. + * The pointer points to the type in the object cache. Thus, clients don't + * need to allocate space for this type and must NEVER free the pointer to the + * 'OCIType'. + */ + +typedef struct OCIType OCIType; + +/*------------------------- TYPE ELEMENT DESCRIPTION ------------------------*/ + + +/* + * OCITypeElem - OCI Type Element object + * + * The contents of an 'OCITypeElem' is private/opaque to clients. Clients just + * need to declare and pass 'OCITypeElem' pointers in to the type manager + * functions. + * + * 'OCITypeElem' objects contains type element information such as the numeric + * precision for example, for number objects, and the number of elements for + * arrays. + * They ARE used to describe type attributes, collection elements, + * method parameters, and method results. Hence they are pass in or returned + * by attribute, collection, and method parameter/result accessors. + */ + +typedef struct OCITypeElem OCITypeElem; + + +/*--------------------------- METHOD DESCRIPTION ---------------------------*/ + + +/* + * OCITypeMethod - OCI Method Description object + * + * The contents of an 'OCITypeMethod' is private/opaque to clients. Clients + * just need to declare and pass 'OCITypeMethod' pointers in to the type + * manager functions. + * The pointer points to the method in the object cache. Thus, clients don't + * need to allocate space for this type and must NEVER free the pointer to + * the 'OCITypeMethod'. + */ + +typedef struct OCITypeMethod OCITypeMethod; + + +/*--------------------------- TYPE ACCESS ITERATOR --------------------------*/ + +/* + * OCITypeIter- OCI Type Iterator + * + * The contents of an 'orti' is private/opaque to clients. Clients just + * need to declare and pass 'orti' pointers in to the type manager functions. + * The iterator is used to retreive MDO's and ADO's that belong to the TDO + * one at a time. It needs to be allocated by the 'OCITypeIterNew()' function + * call and deallocated with the 'OCITypeIterFree()' function call. + */ + +typedef struct OCITypeIter OCITypeIter; + + +/*==================*/ +/* PUBLIC FUNCTIONS */ +/*==================*/ + +/*--------------------------------------------------------------------------*/ +/* ITERATOR */ +/*--------------------------------------------------------------------------*/ + +/*-----------------------_- OCITypeIterNew ---------------------------------*/ + +/* ** OBSOLETE ** */ +sword OCITypeIterNew( OCIEnv *env, OCIError *err, OCIType *tdo, + OCITypeIter **iterator_ort ); + +/* + NAME: OCITypeIterNew - OCI Iterator NEW + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + tdo (IN) - pointer to the pinned type in the object cache to + initialize the iterator with + iterator_ort (OUT) - pointer to the pointer to the new iterator created + DESCRIPTION: + Create a new instance of a method/attribute iterator and initalize + it's values. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is null. + OCI_ERROR if + 1) any of the required parameters is null. + 2) error while allocating space for the iterator. +*/ + +/*------------------------ OCITypeIterSet ---------------------------------*/ + +/* ** OBSOLETE ** */ +sword OCITypeIterSet( OCIEnv *env, OCIError *err, OCIType *tdo, + OCITypeIter *iterator_ort ); + +/* + NAME: OCITypeIterSet - OCI Iterator SET + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + tdo (IN) - pointer to the pinned type in the object cache to + initialize the iterator with + iterator_ort (IN/OUT) - pointer to the iterator to set + DESCRIPTION: + Initializes the iterator. This is used to reset the state of the + iterator. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is null. + OCI_ERROR if + 1) any of the required parameters is null. +*/ + +/*------------------------ OCITypeIterFree ---------------------------------*/ + +/* ** OBSOLETE ** */ +sword OCITypeIterFree( OCIEnv *env, OCIError *err, OCITypeIter + *iterator_ort ); + +/* + NAME: OCITypeIterFree - OCI Iterator FREe + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + iterator_ort (IN/OUT) - pointer to the iterator to free + DESCRIPTION: + Free space allocated for the iterator. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is null. + OCI_ERROR if + 1) any of the required parameters is null. + 2) error while freeing the iterator, probably bad iterator pointer. +*/ + + +/*--------------------------------------------------------------------------*/ +/* TYPE GET */ +/*--------------------------------------------------------------------------*/ + +/* ** OBSOLETE ** */ +sword OCITypeByName( OCIEnv *env, OCIError *err, const OCISvcCtx *svc, + const oratext *schema_name, ub4 s_length, + const oratext *type_name, ub4 t_length, + const oratext *version_name, ub4 v_length, + OCIDuration pin_duration, OCITypeGetOpt get_option, + OCIType **tdo ); +/* + NAME: OCITypeByName - OCI Get the most current version of an existing TYPe + by name. + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + svc (IN) - OCI service handle + schema_name (IN, optional) - name of schema associated with the + type. By default, the user's schema name is used. + s_length (IN) - length of the 'schema_name' parameter + type_name (IN) - name of the type to get + t_length (IN) - length of the 'type_name' parameter + version_name (IN, optional) - user readable version of the type. + Pass (oratext *)0 for the most current version. + v_length (IN) - length of version_name in bytes. Should be 0 if + the most current version is to be retrieved. + pin_duration (IN) - pin duration (e.g. until the end of current + transaction). See 'oro.h' for a description of + each option. + get_option (IN) - options for loading the types. It can be one of two + values: + OCI_TYPEGET_HEADER for only the header to be loaded, or + OCI_TYPEGET_ALL for the TDO and all ADO and MDOs to be + loaded. + tdo (OUT) - pointer to the pinned type in the object cache + DESCRIPTION: + Get a pointer to a version of the existing type associated + with schema/type name. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is null. + OCI_ERROR if + 1) any of the required parameters is null. + 2) the adt type associated with schema/type name does not exist. + NOTE: + Schema and type names are CASE-SENSITIVE. If they have been created + via SQL, you need to use uppercase names. +*/ + +sword OCITypeArrayByName( OCIEnv *env, OCIError *err, const OCISvcCtx *svc, + ub4 array_len, + const oratext *schema_name[], ub4 s_length[], + const oratext *type_name[], ub4 t_length[], + const oratext *version_name[], ub4 v_length[], + OCIDuration pin_duration, + OCITypeGetOpt get_option, OCIType **tdo ); + +/* + NAME: OCITypeArrayByName - OCI Get array of TYPes by name. + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + svc (IN) - OCI service handle + array_len (IN) - number of schema_name/type_name/version_name entries to + be retrieved. + schema_name (IN, optional) - array of schema names associated with the + types to be retrieved. The array must have array_len + elements if specified. + If 0 is supplied, the default schema is assumed, otherwise + it MUST have array_len number of elements. + 0 can be supplied for one or more of the entries to indicate + that the default schema is desired for those entries. + s_length (IN) - array of schema_name lengths with each entry + corresponding to the length of the corresponding schema_name + entry in the schema_name array in bytes. + The array must either have array_len number of elements or + it MUST be 0 if schema_name is not specified. + type_name (IN) - array of the names of the types to retrieve. This + MUST have array_len number of elements. + t_length (IN) - array of the lengths of type names in the type_name + array in bytes. + version_name (IN) - array of the version names of the types to retrieve + corresponding. This can be 0 to indicate retrieval of the + most current versions, or it MUST have array_len number of + elements. + If 0 is supplied, the most current version is assumed, + otherwise it MUST have array_len number of elements. + 0 can be supplied for one or more of the entries to indicate + that the current version is desired for those entries. + v_length (IN) - array of the lengths of version names in the + version_name array in bytes. + pin_duration (IN) - pin duration (e.g. until the end of current + transaction) for the types retreieve. See 'oro.h' for a + description of each option. + get_option (IN) - options for loading the types. It can be one of two + values: + OCI_TYPEGET_HEADER for only the header to be loaded, or + OCI_TYPEGET_ALL for the TDO and all ADO and MDOs to be + loaded. + tdo (OUT) - output array for the pointers to each pinned type in the + object cache. It must have space for array_len pointers. + Use OCIObjectGetObjectRef() to obtain the CREF to each + pinned type descriptor. + DESCRIPTION: + Get pointers to the existing types associated with the schema/type name + array. This is similar to OCITypeByName() except that all the TDO's are + retreived via a single network roundtrip. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is null. + OCI_ERROR if + 1) any of the required parameters is null. + 2) one or more adt types associated with a schema/type name entry + does not exist. +*/ + +sword OCITypeByRef( OCIEnv *env, OCIError *err, + const OCIRef *type_ref, OCIDuration pin_duration, + OCITypeGetOpt get_option, OCIType **tdo ); + +/* + NAME: OCITypeArrayByRef - OCI Get array of TYPes by REF. + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + type_ref (IN) - OCIRef * pointing to the particular version of + the type descriptor object to obtain. + The array must have array_len elements if specified. + pin_duration (IN) - pin duration (e.g. until the end of current + transaction) for the type to retreieve. See 'oro.h' for a + description of each option. + get_option (IN) - options for loading the type. It can be one of two + values: + OCI_TYPEGET_HEADER for only the header to be loaded, or + OCI_TYPEGET_ALL for the TDO and all ADO and MDOs to be + loaded. + tdo (OUT) - pointer to the pinned type in the object cache + DESCRIPTION: + Get pointers to the + with the schema/type name array. This is similar to OCITypeByName() + except that all the TDO's are retreived via a single network roundtrip. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is null. + OCI_ERROR if + 1) any of the required parameters is null. + 2) one or more adt types associated with a schema/type name entry + does not exist. +*/ + +sword OCITypeArrayByRef( OCIEnv *env, OCIError *err, + ub4 array_len, const OCIRef **type_ref, + OCIDuration pin_duration, + OCITypeGetOpt get_option, OCIType **tdo ); + +/* + NAME: OCITypeArrayByRef - OCI Get array of TYPes by REF. + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + array_len (IN) - number of schema_name/type_name/version_name entries to + be retrieved. + type_ref (IN) - array of OCIRef * pointing to the particular version of + the type descriptor object to obtain. + The array must have array_len elements if specified. + pin_duration (IN) - pin duration (e.g. until the end of current + transaction) for the types retreieve. See 'oro.h' for a + description of each option. + get_option (IN) - options for loading the types. It can be one of two + values: + OCI_TYPEGET_HEADER for only the header to be loaded, or + OCI_TYPEGET_ALL for the TDO and all ADO and MDOs to be + loaded. + tdo (OUT) - output array for the pointers to each pinned type in the + object cache. It must have space for array_len pointers. + Use OCIObjectGetObjectRef() to obtain the CREF to each + pinned type descriptor. + DESCRIPTION: + Get pointers to the + with the schema/type name array. This is similar to OCITypeByName() + except that all the TDO's are retreived via a single network roundtrip. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is null. + OCI_ERROR if + 1) any of the required parameters is null. + 2) one or more adt types associated with a schema/type name entry + does not exist. +*/ + + +/*--------------------------------------------------------------------------*/ +/* TYPE ACCESSORS */ +/*--------------------------------------------------------------------------*/ + +/*---------------------------- OCITypeName ---------------------------------*/ + +/* ** OBSOLETE ** */ +oratext* OCITypeName( OCIEnv *env, OCIError *err, const OCIType *tdo, + ub4 *n_length ); +/* + NAME: OCITypeName - ORT Get a Type's naME. + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + tdo (IN) - pointer to to the type descriptor in the object cache + n_length (OUT) - length (in bytes) of the returned type name. The + caller must allocate space for the ub4 before calling this + routine. + REQUIRES: + 1) All type accessors require that the type be pinned before calling + any accessor. + 2) All input parameters must not be NULL and must be valid. + 3) 'n_length' must point to an allocated ub4. + DESCRIPTION: + Get the name of the type. + RETURNS: + the name of the type + NOTES: + The type descriptor, 'tdo', must be unpinned when the accessed + information is no longer needed. + */ + +/*------------------------ OCITypeSchema ---------------------------------*/ + +/* ** OBSOLETE ** */ +oratext* OCITypeSchema( OCIEnv *env, OCIError *err, const OCIType *tdo, + ub4 *n_length ); +/* + NAME: OCITypeSchema - ORT Get a Type's SCHema name. + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + tdo (IN) - pointer to to the type descriptor in the object cache + n_length (OUT) - length (in bytes) of the returned schema name. The + caller must allocate space for the ub4 before calling this + routine. + REQUIRES: + 1) All type accessors require that the type be pinned before calling + any accessor. + 2) All input parameters must not be NULL and must be valid. + 3) 'n_length' must point to an allocated ub4. + DESCRIPTION: + Get the schema name of the type. + RETURNS: + the schema name of the type + NOTES: + The type descriptor, 'tdo', must be unpinned when the accessed + information is no longer needed. + */ + +/*------------------------ OCITypeTypeCode ---------------------------------*/ + +/* ** OBSOLETE ** */ +OCITypeCode OCITypeTypeCode( OCIEnv *env, OCIError *err, + const OCIType *tdo ); +/* + NAME: OCITypeTypeCode - OCI Get a Type's Type Code. + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + tdo (IN) - pointer to to the type descriptor in the object cache + REQUIRES: + 1) All type accessors require that the type be pinned before calling + any accessor. + 2) All input parameters must not be NULL and must be valid. + DESCRIPTION: + Get the type code of the type. + RETURNS: + The type code of the type. + NOTES: + The type descriptor, 'tdo', must be unpinned when the accessed + information is no longer needed. + */ + +/*----------------------- OCITypeCollTypeCode -------------------------------*/ + +/* ** OBSOLETE ** */ +OCITypeCode OCITypeCollTypeCode( OCIEnv *env, OCIError *err, + const OCIType *tdo ); +/* + NAME: OCITypeCollTypeCode - OCI Get a Domain Type's Type Code. + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + tdo (IN) - pointer to to the type descriptor in the object cache + REQUIRES: + 1) All type accessors require that the type be pinned before calling + any accessor. + 2) All input parameters must not be NULL and must be valid. + 3) 'tdo' MUST point to a named collection type. + DESCRIPTION: + Get the type code of the named collection type. For V8.0, named + collection types can only be variable length arrays and nested tables. + RETURNS: + OCI_TYPECODE_VARRAY for variable length array, and + OCI_TYPECODE_TABLE for nested tables. + NOTES: + The type descriptor, 'tdo', should be unpinned when the accessed + information is no longer needed. + */ + +/*------------------------- OCITypeVersion ---------------------------------*/ + +/* ** OBSOLETE ** */ +oratext* OCITypeVersion( OCIEnv *env, OCIError *err, const OCIType *tdo, + ub4 *v_length ); +/* + NAME: OCITypeVersion - OCI Get a Type's user-readable VersioN. + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + tdo (IN) - pointer to to the type descriptor in the object cache + v_length (OUT) - length (in bytes) of the returned user-readable + version. The caller must allocate space for the ub4 before + calling this routine. + REQUIRES: + 1) All type accessors require that the type be pinned before calling + any accessor. + 2) All input parameters must not be NULL and must be valid. + 3) 'v_length' must point to an allocated ub4. + DESCRIPTION: + Get the user-readable version of the type. + RETURNS: + The user-readable version of the type + NOTES: + The type descriptor, 'tdo', must be unpinned when the accessed + information is no longer needed. + */ + +/*--------------------------- OCITypeAttrs ---------------------------------*/ + +/* ** OBSOLETE ** */ +ub4 OCITypeAttrs( OCIEnv *env, OCIError *err, const OCIType *tdo ); +/* + NAME: OCITypeAttrs - OCI Get a Type's Number of Attributes. + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + tdo (IN) - pointer to to the type descriptor in the object cache + REQUIRES: + 1) All type accessors require that the type be pinned before calling + any accessor. + 2) All input parameters must not be NULL and must be valid. + DESCRIPTION: + Get the number of attributes in the type. + RETURNS: + The number of attributes in the type. 0 for ALL non-ADTs. + NOTES: + The type descriptor, 'tdo', must be unpinned when the accessed + information is no longer needed. + */ + +/*------------------------- OCITypeMethods ---------------------------------*/ + +/* ** OBSOLETE ** */ +ub4 OCITypeMethods( OCIEnv *env, OCIError *err, const OCIType *tdo ); +/* + NAME: OCITypeMethods - OCI Get a Type's Number of Methods. + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + tdo (IN) - pointer to to the type descriptor in the object cache + REQUIRES: + 1) All type accessors require that the type be pinned before calling + any accessor. + 2) All input parameters must not be NULL and must be valid. + DESCRIPTION: + Get the number of methods in a type. + RETURNS: + The number of methods in the type + NOTES: + The type descriptor, 'tdo', must be unpinned when the accessed + information is no longer needed. + */ + + +/*--------------------------------------------------------------------------*/ +/* TYPE ELEMENT INFORMATION ACCESSORS */ +/*--------------------------------------------------------------------------*/ + +/*------------------------ OCITypeElemName ---------------------------------*/ + +/* ** OBSOLETE ** */ +oratext* OCITypeElemName( OCIEnv *env, OCIError *err, + const OCITypeElem *elem, ub4 *n_length ); +/* + NAME: OCITypeElemName - OCI Get an Attribute's NaMe. + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + elem (IN) - pointer to the type element descriptor in the object cache + n_length (OUT) - length (in bytes) of the returned attribute name. + The caller must allocate space for the ub4 before calling this + routine. + REQUIRES: + 1) All type accessors require that the type be pinned before calling + any accessor. + 2) All input parameters must not be NULL and must be valid. + 3) 'n_length' must point to an allocated ub4. + DESCRIPTION: + Get the name of the attribute. + RETURNS: + the name of the attribute and the length in n_length + NOTES: + The type must be unpinned when the accessed information is no + longer needed. + */ + +/*------------------------ OCITypeElemTypeCode ------------------------------*/ + +/* ** OBSOLETE ** */ +OCITypeCode OCITypeElemTypeCode( OCIEnv *env, OCIError *err, + const OCITypeElem *elem ); +/* + NAME: OCITypeElemTypeCode - OCI Get an Attribute's TypeCode. + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + elem (IN) - pointer to the type element descriptor in the object cache + REQUIRES: + 1) All type accessors require that the type be pinned before calling + any accessor. + 2) All input parameters must not be NULL and must be valid. + DESCRIPTION: + Get the typecode of an attribute's type. + RETURNS: + the typecode of the attribute's type. If this is a scalar type, the + typecode sufficiently describes the scalar type and no further calls + need to be made. Valid scalar types include: OCI_TYPECODE_SIGNED8, + OCI_TYPECODE_UNSIGNED8, OCI_TYPECODE_SIGNED16, OCI_TYPECODE_UNSIGNED16, + OCI_TYPECODE_SIGNED32, OCI_TYPECODE_UNSIGNED32, OCI_TYPECODE_REAL, + OCI_TYPECODE_DOUBLE, OCI_TYPECODE_DATE, + OCI_TYPECODE_MLSLABEL, OROTCOID, OCI_TYPECODE_OCTET, or OROTCLOB. + This function converts the CREF (stored in the attribute) into a + typecode. + NOTES: + The type must be unpinned when the accessed information is no + longer needed. + */ + +/*------------------------ OCITypeElemType ---------------------------------*/ + +/* ** OBSOLETE ** */ +sword OCITypeElemType( OCIEnv *env, OCIError *err, const OCITypeElem *elem, + OCIType **elem_tdo ); +/* + PARAMETERS + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + elem (IN) - pointer to the type element descriptor in the object cache + elem_tdo (OUT) - If the function completes successfully, 'elem_tdo' + points to the type descriptor (in the object cache) of the type of + the element. + + REQUIRES + 1) All type accessors require that the type be pinned before calling + any accessor. This can be done by calling 'OCITypeByName()'. + 2) if 'elem' is not null, it must point to a valid type element descriptor + in the object cache. + + DESCRIPTION + Get the type tdo of the type of this element. + RETURNS + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is null. + OCI_ERROR if + 1) any of the parameters is null. + + NOTES + The type must be unpinned when the accessed information is no + longer needed. This can be done by calling 'OCIObjectUnpin()'. + */ + +/*------------------------- OCITypeElemFlags -------------------------------*/ + +/* ** OBSOLETE ** */ +ub4 OCITypeElemFlags( OCIEnv *env, OCIError *err, + const OCITypeElem *elem ); +/* + NAME: OCITypeElemFlags - OCI Get a Elem's FLags + (inline, constant, virtual, constructor, + destructor). + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + elem (IN) - pointer to the type element descriptor in the object cache + REQUIRES: + 1) All type accessors require that the type be pinned before calling + any accessor. + 2) All input parameters must not be NULL and must be valid. + DESCRIPTION: + Get the flags of a type element (attribute, parameter). + RETURNS: + The flags of the type element. + NOTES: + The flag bits are not externally documented. Use only the macros + in the last section (ie. OCI_TYPEPARAM_IS_REQUIRED, and + OCI_TYPEELEM_IS_REF) to test for them only. The type must be unpinned + when the accessed information is no longer needed. + */ + +/*------------------------ OCITypeElemNumPrec ------------------------------*/ + +/* ** OBSOLETE ** */ +ub1 OCITypeElemNumPrec( OCIEnv *env, OCIError *err, + const OCITypeElem *elem ); +/* + NAME: OCITypeElemNumPrec - Get a Number's Precision. This includes float, + decimal, real, double, and oracle number. + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + elem (IN) - pointer to the type element descriptor in the object cache + REQUIRES: + All input parameters must not be NULL and must be valid. + DESCRIPTION: + Get the precision of a float, decimal, long, unsigned long, real, + double, or Oracle number type. + RETURNS: + the precision of the float, decimal, long, unsigned long, real, double, + or Oracle number + */ + +/*------------------------- OCITypeElemNumScale -----------------------------*/ + +/* ** OBSOLETE ** */ +sb1 OCITypeElemNumScale( OCIEnv *env, OCIError *err, + const OCITypeElem *elem ); +/* + NAME: OCITypeElemNumScale - Get a decimal or oracle Number's Scale + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + elem (IN) - pointer to the type element descriptor in the object cache + REQUIRES: + All input parameters must not be NULL and must be valid. + DESCRIPTION: + Get the scale of a decimal, or Oracle number type. + RETURNS: + the scale of the decimal, or Oracle number + */ + +/*------------------------ OCITypeElemLength -------------------------------*/ + +/* ** OBSOLETE ** */ +ub4 OCITypeElemLength( OCIEnv *env, OCIError *err, + const OCITypeElem *elem ); +/* + NAME: OCITypeElemLength - Get a raw, fixed or variable length String's + length in bytes. + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + elem (IN) - pointer to the type element descriptor in the object cache + REQUIRES: + All input parameters must not be NULL and must be valid. + DESCRIPTION: + Get the length of a raw, fixed or variable length string type. + RETURNS: + length of the raw, fixed or variable length string + */ + +/*----------------------- OCITypeElemCharSetID -----------------------------*/ + +/* ** OBSOLETE ** */ +ub2 OCITypeElemCharSetID( OCIEnv *env, OCIError *err, + const OCITypeElem *elem ); +/* + NAME: OCITypeElemCharSetID - Get a fixed or variable length String's + character set ID + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + elem (IN) - pointer to the type element descriptor in the object cache + REQUIRES: + All input parameters must not be NULL and must be valid. + DESCRIPTION: + Get the character set ID of a fixed or variable length string type. + RETURNS: + character set ID of the fixed or variable length string + */ + +/*---------------------- OCITypeElemCharSetForm ----------------------------*/ + +/* ** OBSOLETE ** */ +ub2 OCITypeElemCharSetForm( OCIEnv *env, OCIError *err, + const OCITypeElem *elem ); +/* + NAME: OCITypeElemCharSetForm - Get a fixed or variable length String's + character set specification form. + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + elem (IN) - pointer to the attribute information in the object cache + REQUIRES: + All input parameters must not be NULL and must be valid. + DESCRIPTION: + Get the character form of a fixed or variable length string type. + The character form is an enumerated value that can be one of the + 4 values below: + SQLCS_IMPLICIT for CHAR, VARCHAR2, CLOB w/o a specified set + SQLCS_NCHAR for NCHAR, NCHAR VARYING, NCLOB + SQLCS_EXPLICIT for CHAR, etc, with "CHARACTER SET ..." syntax + SQLCS_FLEXIBLE for PL/SQL "flexible" parameters + RETURNS: + character form of the fixed or variable string + */ + +/*--------------------- OCITypeElemParameterizedType ------------------------*/ + +/* ** OBSOLETE ** */ +sword OCITypeElemParameterizedType( OCIEnv *env, OCIError *err, + const OCITypeElem *elem, + OCIType **type_stored ); +/* + NAME: OCITypeElemParameterizedType + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + elem (IN) - pointer to the type element descriptor in the object cache + type_stored (OUT) - If the function completes successfully, + and the parameterized type is complex, 'type_stored' is NULL. + Otherwise, 'type_stored' points to the type descriptor (in the + object cache) of the type that is stored in the parameterized + type. The caller must allocate space for the OCIType* + before calling this routine and must not write into the space. + REQUIRES: + All input parameters must be valid. + DESCRIPTION: + Get a descriptor to the parameter type of a parameterized type. + Parameterized types are types of the form: + REF T + VARRAY (n) OF T + etc, where T is the parameter in the parameterized type. + Additionally is_ref is set if the parameter is a PTR or REF. + For example, it is set for REF T or VARRAY(n) OF REF T. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is null. + OCI_ERROR if + 1) any of the parameters is null. + 2) 'type_stored' is not NULL but points to NULL data. + NOTES: + Complex parameterized types will be in a future release (once + typedefs are supported. When setting the parameterized type + information, the user must typedef the contents if it's a + complex parameterized type. Ex. for varray>, use + 'typedef varray varcar' and then use varray. + */ + +/*----------------------- OCITypeElemExtTypeCode ----------------------------*/ + +/* ** OBSOLETE ** */ +OCITypeCode OCITypeElemExtTypeCode( OCIEnv *env, OCIError *err, + const OCITypeElem *elem ); +/* + NAME: OCITypeElemExtTypeCode - OCI Get an element's SQLT constant. + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + elem (IN) - pointer to the type element descriptor in the object cache + REQUIRES: + 1) All type accessors require that the type be pinned before calling + any accessor. + 2) All input parameters must not be NULL and must be valid. + DESCRIPTION: + Get the internal Oracle typecode associated with an attribute's type. + This is the actual typecode for the attribute when it gets mapped + to a column in the Oracle database. + RETURNS: + The Oracle typecode associated with the attribute's type. + NOTES: + The type must be unpinned when the accessed information is no + longer needed. + */ + +/*--------------------------------------------------------------------------*/ +/* ATTRIBUTE ACCESSORS */ +/*--------------------------------------------------------------------------*/ + +/*------------------------ OCITypeAttrByName -------------------------------*/ + +/* ** OBSOLETE ** */ +sword OCITypeAttrByName( OCIEnv *env, OCIError *err, const OCIType *tdo, + const oratext *name, ub4 n_length, + OCITypeElem **elem ); +/* + NAME: OCITypeAttrByName - OCI Get an Attribute By Name. + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + tdo (IN) - pointer to to the type descriptor in the object cache + name (IN) - the attribute's name + n_length (IN) - length (in bytes) of the 'name' parameter + elem (OUT) - If this function completes successfully, 'elem' points to + the selected type element descriptor pertaining to the + attributein the object cache. + REQUIRES: + 1) All type accessors require that the type be pinned before calling + any accessor. + 2) if 'tdo' is not null, it must point to a valid type descriptor + in the object cache. + DESCRIPTION: + Get an attribute given its name. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is null. + OCI_ERROR if + 1) any of the required parameters is null. + 2) the type does not contain an attribute with the input 'name'. + 3) 'name' is NULL. + NOTES: + The type descriptor, 'tdo', must be unpinned when the accessed + information is no longer needed. + Schema and type names are CASE-SENSITIVE. If they have been created + via SQL, you need to use uppercase names. + */ + +/*------------------------ OCITypeAttrNext ---------------------------------*/ + +/* ** OBSOLETE ** */ +sword OCITypeAttrNext( OCIEnv *env, OCIError *err, + OCITypeIter *iterator_ort, OCITypeElem **elem ); + +/* + NAME: OCITypeAttrNext - OCI Get an Attribute By Iteration. + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + iterator_ort (IN/OUT) - iterator for retrieving the next attribute; + see OCITypeIterNew() to initialize iterator. + elem (OUT) - If this function completes successfully, 'elem' points to + the selected type element descriptor pertaining to the + attributein the object cache. + REQUIRES: + 1) All type accessors require that the type be pinned before calling + any accessor. + 2) if 'tdo' is not null, it must point to a valid type descriptor + in the object cache. + DESCRIPTION: + Iterate to the next attribute to retrieve. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_NO_DATA if there are no more attributes to iterate on; use + OCITypeIterSet() to reset the iterator if necessary. + OCI_INVALID_HANDLE if 'env' or 'err' is null. + OCI_ERROR if + 1) any of the required parameters is null. + NOTES: + The type must be unpinned when the accessed information is no + longer needed. + */ + +/*--------------------------------------------------------------------------*/ +/* COLLECTION ACCESSORS */ +/*--------------------------------------------------------------------------*/ + +/*------------------------ OCITypeCollElem ---------------------------------*/ + +/* ** OBSOLETE ** */ +sword OCITypeCollElem( OCIEnv *env, OCIError *err, const OCIType *tdo, + OCITypeElem **element ); +/* + NAME: OCITypeCollElem + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + tdo (IN) - pointer to the type descriptor in the object cache + element (IN/OUT) - If the function completes successfully, this + points to the descriptor for the collection's element. + It is stored in the same format as an ADT attribute's + descriptor. + If *element is NULL, OCITypeCollElem() implicitly allocates a + new instance of OCITypeElem in the object cache. This instance + will be + automatically freed at the end of the session, and does not have + to be freed explicitly. + If *element is not NULL, OCITypeCollElem() assumes that it + points to a valid OCITypeElem descriptor and will copy the + results into it. + REQUIRES: + All input parameters must be valid. + DESCRIPTION: + Get a pointer to the descriptor (OCITypeElem) of the element of an + array or the rowtype of a nested table. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is null. + OCI_ERROR if + 1) any of the parameters is null. + 2) the type TDO does not point to a valid collection's type. + NOTES: + Complex parameterized types will be in a future release (once + typedefs are supported. When setting the parameterized type + information, the user must typedef the contents if it's a + complex parameterized type. Ex. for varray>, use + 'typedef varray varcar' and then use varray. + */ + +/*------------------------ OCITypeCollSize ---------------------------------*/ + +/* ** OBSOLETE ** */ +sword OCITypeCollSize( OCIEnv *env, OCIError *err, const OCIType *tdo, + ub4 *num_elems ); +/* + NAME: OCITypeCollSize - OCI Get a Collection's Number of Elements. + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + tdo (IN) - pointer to the type descriptor in the object cache + num_elems (OUT) - number of elements in collection + REQUIRES: + All input parameters must be valid. tdo points to an array type + defined as a domain. + DESCRIPTION: + Get the number of elements stored in a fixed array or the maximum + number of elements in a variable array. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is null. + OCI_ERROR if + 1) any of the parameters is null. + 2) 'tdo' does not point to a domain with a collection type. + NOTES: + Complex parameterized types will be in a future release (once + typedefs are supported. When setting the parameterized type + information, the user must typedef the contents if it's a + complex parameterized type. Ex. for varray>, use + 'typedef varray varcar' and then use varray. + */ + +/*------------------------ OCITypeCollExtTypeCode ---------------------------*/ + +/* ** OBSOLETE ** */ +sword OCITypeCollExtTypeCode( OCIEnv *env, OCIError *err, + const OCIType *tdo, OCITypeCode *sqt_code ); +/* + NAME: ortcsqt - OCI Get a Collection element's DTY constant. + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + tdo (IN) - pointer to the type descriptor in the object cache + sqt_code (OUT) - SQLT code of type element. + REQUIRES: + 1) All type accessors require that the type be pinned before calling + any accessor. + 2) All input parameters must not be NULL and must be valid. + DESCRIPTION: + Get the SQLT constant associated with an domain's element type. + The SQLT codes are defined in and are needed for OCI/OOCI + use. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is null. + OCI_ERROR if + 1) any of the parameters is null. + 2) 'tdo' does not point to a domain with a collection type. + NOTES: + The type must be unpinned when the accessed information is no + longer needed. + */ + + +/*--------------------------------------------------------------------------*/ +/* METHOD ACCESSORS */ +/*--------------------------------------------------------------------------*/ + +/*------------------------- OCITypeMethodOverload --------------------------*/ + +/* ** OBSOLETE ** */ +ub4 OCITypeMethodOverload( OCIEnv *env, OCIError *err, const OCIType *tdo, + const oratext *method_name, ub4 m_length ); +/* + NAME: OCITypeMethodOverload - OCI Get type's Number of Overloaded names + for the given method name. + PARAMETERS: + gp (IN/OUT) - pga environment handle. Any errors are recorded here. + tdo (IN) - pointer to to the type descriptor in the object cache + method_name (IN) - the method's name + m_length (IN) - length (in bytes) of the 'method_name' parameter + REQUIRES: + 1) All type accessors require that the type be pinned before calling + any accessor. + 2) if 'tdo' is not null, it must point to a valid type descriptor + in the object cache. + DESCRIPTION: + Overloading of methods implies that more than one method may have the + same method name. This routine returns the number of methods that + have the given method name. If there are no methods with the input + method name, 'num_methods' is 0. The caller uses this information when + allocating space for the array of mdo and/or position pointers before + calling 'OCITypeMethodByName()' or 'ortgmps()'. + RETURNS: + The number of methods with the given name. 0 if none contains the + name. + NOTES: + Schema and type names are CASE-SENSITIVE. If they have been created + via SQL, you need to use uppercase names. + */ + +/*------------------------ OCITypeMethodByName ------------------------------*/ + +/* ** OBSOLETE ** */ +sword OCITypeMethodByName( OCIEnv *env, OCIError *err, const OCIType *tdo, + const oratext *method_name, ub4 m_length, + OCITypeMethod **mdos ); +/* + NAME: OCITypeMethodByName - OCI Get one or more Methods with Name. + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + tdo (IN) - pointer to to the type descriptor in the object cache + method_name (IN) - the methods' name + m_length (IN) - length (in bytes) of the 'name' parameter + mdos (OUT) - If this function completes successfully, 'mdos' points to + the selected methods in the object cache. The caller must + allocate space for the array of OCITypeMethod pointers before + calling this routine and must not write into the space. + The number of OCITypeMethod pointers that will be returned can + be obtained by calling 'OCITypeMethodOverload()'. + REQUIRES: + 1) All type accessors require that the type be pinned before calling + any accessor. + 2) if 'tdo' is not null, it must point to a valid type descriptor + in the object cache. + DESCRIPTION: + Get one or more methods given the name. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is null. + OCI_ERROR if + 1) any of the required parameters is null. + 2) No methods in type has name 'name'. + 3) 'mdos' is not NULL but points to NULL data. + NOTES: + The type must be unpinned when the accessed information is no + longer needed. + Schema and type names are CASE-SENSITIVE. If they have been created + via SQL, you need to use uppercase names. + */ + +/*------------------------ OCITypeMethodNext --------------------------------*/ + +/* ** OBSOLETE ** */ +sword OCITypeMethodNext( OCIEnv *env, OCIError *err, + OCITypeIter *iterator_ort, + OCITypeMethod **mdo ); + +/* + NAME: OCITypeMethodNext - OCI Get a Method By Iteration. + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + iterator_ort (IN/OUT) - iterator for retrieving the next method; + see OCITypeIterNew() to set iterator. + mdo (OUT) - If this function completes successfully, 'mdo' points to + the selected method descriptor in the object cache. Positions + start at 1. The caller must allocate space for the + OCITypeMethod* before calling this routine and must not write + nto the space. + REQUIRES: + 1) All type accessors require that the type be pinned before calling + any accessor. + 2) if 'tdo' is not null, it must point to a valid type descriptor + in the object cache. + DESCRIPTION: + Iterate to the next method to retrieve. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_NO_DATA if there are no more attributes to iterate on; use + OCITypeIterSet() to reset the iterator if necessary. + OCI_INVALID_HANDLE if 'env' or 'err' is null. + OCI_ERROR if + 1) any of the required parameters is null. + 2) 'mdo' is not NULL but points to NULL data. + NOTES: + The type must be unpinned when the accessed information is no + longer needed. + */ + +/*------------------------ OCITypeMethodName --------------------------------*/ + +/* ** OBSOLETE ** */ +oratext *OCITypeMethodName( OCIEnv *env, OCIError *err, + const OCITypeMethod *mdo, ub4 *n_length ); +/* + NAME: OCITypeMethodName - OCI Get a Method's NaMe. + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + mdo (IN) - pointer to the method descriptor in the object cache + n_length (OUT) - length (in bytes) of the 'name' parameter. The caller + must allocate space for the ub4 before calling this routine. + REQUIRES: + 1) All type accessors require that the type be pinned before calling + any accessor. + 2) All input parameters must not be NULL and must be valid. + DESCRIPTION: + Get the (non-unique) real name of the method. + RETURNS: + the non-unique name of the method or NULL if there is an error. + NOTES: + The type must be unpinned when the accessed information is no + longer needed. + */ + +/*------------------------ OCITypeMethodEncap -------------------------------*/ + +/* ** OBSOLETE ** */ +OCITypeEncap OCITypeMethodEncap( OCIEnv *env, OCIError *err, + const OCITypeMethod *mdo ); +/* + NAME: OCITypeMethodEncap - Get a Method's ENcapsulation (private/public). + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + mdo (IN) - pointer to the method descriptor in the object cache + REQUIRES: + 1) All type accessors require that the type be pinned before calling + any accessor. + 2) All input parameters must not be NULL and must be valid. + DESCRIPTION: + Get the encapsulation (private, or public) of a method. + RETURNS: + the encapsulation (private, or public) of the method + NOTES: + The type must be unpinned when the accessed information is no + longer needed. + */ + +/*------------------------ OCITypeMethodFlags -------------------------------*/ + +/* ** OBSOLETE ** */ +OCITypeMethodFlag OCITypeMethodFlags( OCIEnv *env, OCIError *err, + const OCITypeMethod *mdo ); +/* + NAME: OCITypeMethodFlags - OCI Get a Method's FLags + (inline, constant, virtual, constructor, + destructor). + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + mdo (IN) - pointer to the method descriptor in the object cache + REQUIRES: + 1) All type accessors require that the type be pinned before calling + any accessor. + 2) All input parameters must not be NULL and must be valid. + DESCRIPTION: + Get the flags (inline, constant, virutal, constructor, destructor) of + a method. + RETURNS: + the flags (inline, constant, virutal, constructor, destructor) of + the method + NOTES: + The type must be unpinned when the accessed information is no + longer needed. + */ + +/*------------------------ OCITypeMethodMap ---------------------------------*/ + +/* ** OBSOLETE ** */ +sword OCITypeMethodMap( OCIEnv *env, OCIError *err, const OCIType *tdo, + OCITypeMethod **mdo ); +/* + NAME: OCITypeMethodMap - OCI Get the Method's MAP function. + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + tdo (IN) - pointer to to the type descriptor in the object cache + mdo (OUT) - If this function completes successfully, and there is a + map function for this type, 'mdo' points to the selected method + descriptor in the object cache. Otherwise, 'mdo' is null. + REQUIRES: + 1) All type accessors require that the type be pinned before calling + any accessor. + 2) All required input parameters must not be NULL and must be valid. + DESCRIPTION: + A type may have only one map function. 'OCITypeMethodMap()' finds + this function, if it exists, and returns a reference and a pointer to + the method descriptor in the object cache. If the type does not have a + map (relative ordering) function, then 'mdo_ref' and 'mdo' are set + to null and an error is returned. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is null. + OCI_ERROR if + the type does not contain a map function. + NOTES: + The type must be unpinned when the accessed information is no + longer needed. + */ + +/*------------------------ OCITypeMethodOrder -------------------------------*/ + +/* ** OBSOLETE ** */ +sword OCITypeMethodOrder( OCIEnv *env, OCIError *err, const OCIType *tdo, + OCITypeMethod **mdo ); +/* + NAME: OCITypeMethodOrder - OCI Get the Method's ORder function. + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + tdo (IN) - pointer to to the type descriptor in the object cache + mdo (OUT) - If this function completes successfully, and there is a + map function for this type, 'mdo' points to the selected method + descriptor in the object cache. Otherwise, 'mdo' is null. + REQUIRES: + 1) All type accessors require that the type be pinned before calling + any accessor. + 2) All required input parameters must not be NULL and must be valid. + DESCRIPTION: + A type may have only one ORder or MAP function. 'OCITypeMethodOrder()' + finds this function, if it exists, and returns a ref and a pointer + to the method descriptor in the object cache. If the type does not + have a map (relative ordering) function, then 'mdo_ref' and 'mdo' are + set to null and an error is returned. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is null. + OCI_ERROR if + the type does not contain a map function. + NOTES: + The type must be unpinned when the accessed information is no + longer needed. + */ + +/*------------------------ OCITypeMethodParams ------------------------------*/ + +/* ** OBSOLETE ** */ +ub4 OCITypeMethodParams( OCIEnv *env, OCIError *err, + const OCITypeMethod *mdo ); +/* + NAME: OCITypeMethodParams - OCI Get a Method's Number of Parameters. + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + mdo (IN) - pointer to the method descriptor in the object cache + REQUIRES: + 1) All type accessors require that the type be pinned before calling + any accessor. + 2) All input parameters must not be NULL and must be valid. + DESCRIPTION: + Get the number of parameters in a method. + RETURNS: + the number of parameters in the method + NOTES: + The type must be unpinned when the accessed information is no + longer needed. + */ + + +/*--------------------------------------------------------------------------*/ +/* RESULT ACCESSORS */ +/*--------------------------------------------------------------------------*/ + +/*-------------------------- OCITypeResult ---------------------------------*/ + +/* ** OBSOLETE ** */ +sword OCITypeResult( OCIEnv *env, OCIError *err, const OCITypeMethod *mdo, + OCITypeElem **elem ); +/* + NAME: OCITypeResult - OCI Get a method's result type descriptor. + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + mdo (IN) - pointer to the method descriptor in the object cache + elem (OUT) - If this function completes successfully, 'rdo' points to + the selected result (parameter) descriptor in the object cache. + REQUIRES: + 1) All type accessors require that the type be pinned before calling + any accessor. + 2) 'elem' MUST be the address of an OCITypeElem pointer. + DESCRIPTION: + Get the result of a method. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is null. + OCI_ERROR if + 1) any of the required parameters is null. + 2) method returns no results. + NOTES: + The method must be unpinned when the accessed information is no + longer needed. + */ + + +/*--------------------------------------------------------------------------*/ +/* PARAMETER ACCESSORS */ +/*--------------------------------------------------------------------------*/ + +/*------------------------ OCITypeParamByPos -------------------------------*/ + +/* ** OBSOLETE ** */ +sword OCITypeParamByPos( OCIEnv *env, OCIError *err, + const OCITypeMethod *mdo, ub4 position, + OCITypeElem **elem ); +/* + NAME: OCITypeParamByPos - OCI Get a Parameter in a method By Position. + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + mdo (IN) - pointer to the method descriptor in the object cache + position (IN) - the parameter's position. Positions start at 1. + elem (OUT) - If this function completes successfully, 'elem' points to + the selected parameter descriptor in the object cache. + REQUIRES: + 1) All type accessors require that the type be pinned before calling + any accessor. + DESCRIPTION: + Get a parameter given its position in the method. Positions start + at 1. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is null. + OCI_ERROR if + 1) any of the required parameters is null. + 2) 'position' is not >= 1 and <= the number of parameters in the + method. + NOTES: + The type must be unpinned when the accessed information is no + longer needed. + */ + +/*------------------------ OCITypeParamByName -------------------------------*/ + +/* ** OBSOLETE ** */ +sword OCITypeParamByName( OCIEnv *env, OCIError *err, + const OCITypeMethod *mdo, + const oratext *name, ub4 n_length, + OCITypeElem **elem ); +/* + NAME: OCITypeParamByName - OCI Get a Parameter in a method By Name. + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + mdo (IN) - pointer to the method descriptor in the object cache + name (IN) - the parameter's name + n_length (IN) - length (in bytes) of the 'name' parameter + elem (OUT) - If this function completes successfully, 'elem' points to + the selected parameter descriptor in the object cache. + REQUIRES: + 1) All type accessors require that the type be pinned before calling + any accessor. + 2) if 'mdo' is not null, it must point to a valid method descriptor + in the object cache. + DESCRIPTION: + Get a parameter given its name. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is null. + OCI_ERROR if + 1) any of the required parameters is null. + 2) the method does not contain a parameter with the input 'name'. + NOTES: + The type must be unpinned when the accessed information is no + longer needed. + */ + +/*------------------------ OCITypeParamPos ---------------------------------*/ + +/* ** OBSOLETE ** */ +sword OCITypeParamPos( OCIEnv *env, OCIError *err, + const OCITypeMethod *mdo, + const oratext *name, ub4 n_length, ub4 *position, + OCITypeElem **elem ); +/* + NAME: OCITypeParamPos - OCI Get a parameter's position in a method + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + mdo (IN) - pointer to the method descriptor in the object cache + name (IN) - the parameter's name + n_length (IN) - length (in bytes) of the 'name' parameter + position (OUT) - If this function completes successfully, 'position' + points to the position of the parameter in the method starting + at position 1. position MUST point to space for a ub4. + elem (OUT) - If this function completes successfully, and + the input 'elem' is not NULL, 'elem' points to the selected + parameter descriptor in the object cache. + REQUIRES: + 1) All type accessors require that the type be pinned before calling + any accessor. + 2) if 'mdo' is not null, it must point to a valid method descriptor + in the object cache. + DESCRIPTION: + Get the position of a parameter in a method. Positions start at 1. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is null. + OCI_ERROR if + 1) any of the parameters is null. + 2) the method does not contain a parameter with the input 'name'. + NOTES: + The type must be unpinned when the accessed information is no + longer needed. + */ + +/*------------------------ OCITypeParamElemMode -----------------------------*/ + +/* ** OBSOLETE ** */ +OCITypeParamMode OCITypeElemParamMode( OCIEnv *env, OCIError *err, + const OCITypeElem *elem ); +/* + NAME: OCITypeElemParamMode - OCI Get a parameter's mode + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + elem (IN) - pointer to the parameter descriptor in the object cache + (represented by an OCITypeElem) + REQUIRES: + 1) All type accessors require that the type be pinned before calling + any accessor. + 2) All input parameters must not be NULL and must be valid. + DESCRIPTION: + Get the mode (in, out, or in/out) of the parameter. + RETURNS: + the mode (in, out, or in/out) of the parameter + NOTES: + The type must be unpinned when the accessed information is no + longer needed. + */ + +/*------------------------- OCITypeElemDefaultValue -------------------------*/ + +/* ** OBSOLETE ** */ +oratext* OCITypeElemDefaultValue( OCIEnv *env, OCIError *err, + const OCITypeElem *elem, + ub4 *d_v_length ); +/* + NAME: OCITypeElemDefaultValue - OCI Get the element's Default Value. + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + elem (IN) - pointer to the parameter descriptor in the object cache + (represented by an OCITypeElem) + d_v_length (OUT) - length (in bytes) of the returned default value. + The caller must allocate space for the ub4 before calling this + routine. + REQUIRES: + 1) All type accessors require that the type be pinned before calling + any accessor. + 2) All input parameters must not be NULL and must be valid. + DESCRIPTION: + Get the default value in text form (PL/SQL) of an element. For V8.0, + this only makes sense for a method parameter. + RETURNS: + The default value (text) of the parameter. + NOTES: + The type must be unpinned when the accessed information is no + longer needed. + */ + + +/*--------------------------------------------------------------------------*/ +/* TYPE VERSION TABLE */ +/*--------------------------------------------------------------------------*/ + +/* For V8.0, the type version table is meant to be an internal data structure + only for Oracle clients for type version maintanence purposes. A more + general version of the API may be made public in subsequent releases. */ + + +/*--------------------------- OCITypeVTInit --------------------------------*/ + +/* ** OBSOLETE ** */ +sword OCITypeVTInit( OCIEnv *env, OCIError *err ); +/* + NAME: OCITypeVTInit - OCI type Version table INItialize + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + REQUIRES: + none + DESCRIPTION: + Allocate space for and initialize the type version table and the type + version table's index. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is null. + OCI_ERROR if internal errors occurrs during initialization. + */ + +/*--------------------------- OCITypeVTInsert -------------------------------*/ + +/* ** OBSOLETE ** */ +sword OCITypeVTInsert( OCIEnv *env, OCIError *err, + const oratext *schema_name, ub4 s_n_length, + const oratext *type_name, ub4 t_n_length, + const oratext *user_version, ub4 u_v_length ); +/* + NAME: OCITypeVTInsert - OCI type Version table INSert entry. + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + schema_name (IN, optional) - name of schema associated with the + type. By default, the user's schema name is used. + s_n_length (IN) - length of the 'schema_name' parameter + type_name (IN) - type name to insert + t_n_length (IN) - length (in bytes) of the 'type_name' parameter + user_version (IN) - user readable version of the type + u_v_length (IN) - length (in bytes) of the 'user_version' parameter + REQUIRES: + none + DESCRIPTION: + Insert an entry into the type version table and the type version + table's index. The entry's type name and user readable version + fields are updated with the input values. All other fields are + initialized to null. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is null. + OCI_ERROR if + 1) any of the parameters is invalid. + 2) an entry for 'type_name' has already been registered in the + type version table. + */ + +/*------------------------------ OCITypeVTSelect ----------------------------*/ + +/* OCITypeVTSelect - OCI type VERSion table SELECT entry */ +/* ** OBSOLETE ** */ +sword OCITypeVTSelect( OCIEnv *env, OCIError *err, + const oratext *schema_name, ub4 s_n_length, + const oratext *type_name, ub4 t_n_length, + oratext **user_version, ub4 *u_v_length, + ub2 *version ); +/* + NAME: OCITypeVTSelect - OCI type Version table SELect entry. + PARAMETERS: + env (IN/OUT) - OCI environment handle initialized in object mode + err (IN/OUT) - error handle. If there is an error, it is + recorded in 'err' and this function returns OCI_ERROR. + The error recorded in 'err' can be retrieved by calling + OCIErrorGet(). + schema_name (IN, optional) - name of schema associated with the + type. By default, the user's schema name is used. + s_n_length (IN) - length of the 'schema_name' parameter + type_name (IN) - type name to select + t_n_length (IN) - length (in bytes) of the 'type_name' parameter + user_version (OUT, optional) - pointer to user readable version of the + type + u_v_length (OUT, optional) - length (in bytes) of the 'user_version' + parameter + version (OUT, optional) - internal type version + REQUIRES: + All input parameters must not be NULL and must be valid. + DESCRIPTION: + Select an entry in the type version table by name. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_INVALID_HANDLE if 'env' or 'err' is null. + OCI_ERROR if + 1) any of the parameters is invalid. + 2) an entry with 'type_name' does not exist. + */ + +/* Compatibility function - following function prototype retained for + compatibility only */ +sword ortgcty( OCIEnv *env, OCIError *err, OCIType *coll_tdo, + OCIType **collelem_tdo ); + +/*---------------------------------------------------------------------------*/ +/* Transient Type Construction functions */ +/*---------------------------------------------------------------------------*/ + +sword OCITypeBeginCreate(OCISvcCtx *svchp, OCIError *errhp, OCITypeCode tc, + OCIDuration dur, OCIType **type); +/* + NAME: OCITypeBeginCreate - OCI Type Begin Creation of a transient type. + REMARKS + Begins the construction process for a transient type. The type will be + anonymous (no name). To create a persistent named type, the CREATE TYPE + statement should be used from SQL. Transient types have no identity. + They are pure values. + PARAMETERS: + svchp (IN) - The OCI Service Context. + errhp (IN/OUT) - The OCI error handle. If there is an error, it is + recorded in errhp and this function returns + OCI_ERROR. Diagnostic information can be obtained by + calling OCIErrorGet(). + tc - The TypeCode for the type. The Typecode could + correspond to a User Defined Type or a Built-in type. + Currently, the permissible values for User Defined + Types are OCI_TYPECODE_OBJECT for an Object Type + (structured), OCI_TYPECODE_VARRAY for a VARRAY + collection type or OCI_TYPECODE_TABLE for a nested + table collection type. For Object types, + OCITypeAddAttr() needs to be called to add each of + the attribute types. For Collection types, + OCITypeSetCollection() needs to be called. + Subsequently, OCITypeEndCreate() needs to be called + to finish the creation process. + The permissible values for Built-in type codes are + specified in the user manual. Additional information + on built-ins if any (like precision, scale for + numbers, character set info for VARCHAR2s etc.) must + be set with a subsequent call to OCITypeSetBuiltin(). + Subsequently OCITypeEndCreate() needs to be called + to finish the creation process. + dur - The allocation duration for the Type. Could be a + predefined or a user defined duration. + type(OUT) - The OCIType (Type Descriptor) that is being + constructed. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_ERROR on error. +*/ + + +sword OCITypeSetCollection(OCISvcCtx *svchp, OCIError *errhp, OCIType *type, + OCIParam *collelem_info, ub4 coll_count); +/* + NAME: OCITypeSetCollection - OCI Type Set Collection information + REMARKS : + Set Collection type information. This call can be called only if the + OCIType has been constructed with a collection typecode. + PARAMETERS: + svchp (IN) - The OCI Service Context. + errhp (IN/OUT) - The OCI error handle. If there is an error, it is + recorded in errhp and this function returns + OCI_ERROR. Diagnostic information can be obtained by + calling OCIErrorGet(). + type(IN OUT) - The OCIType (Type Descriptor) that is being + constructed. + collelem_info - collelem_info provides information on the collection + element. It is obtained by allocating an OCIParam + (parameter handle) and setting type information in + the OCIParam using OCIAttrSet() calls. + coll_count - The count of elements in the collection. Pass 0 for + a nested table (unbounded). + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_ERROR on error. +*/ + +sword OCITypeSetBuiltin(OCISvcCtx *svchp, OCIError *errhp, OCIType *type, + OCIParam *builtin_info); +/* + NAME: OCITypeSetBuiltin - OCI Type Set Builtin information. + REMARKS: + Set Built-in type information. This call can be called only if the + OCIType has been constructed with a built-in typecode + (OCI_TYPECODE_NUMBER etc.). + PARAMETERS: + svchp (IN) - The OCI Service Context. + errhp (IN/OUT) - The OCI error handle. If there is an error, it is + recorded in errhp and this function returns + OCI_ERROR. Diagnostic information can be obtained by + calling OCIErrorGet(). + type(IN OUT) - The OCIType (Type Descriptor) that is being + constructed. + builtin_info - builtin_info provides information on the built-in + (like precision, scale, charater set etc.). It is + obtained by allocating an OCIParam (parameter handle) + and setting type information in the OCIParam using + OCIAttrSet() calls. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_ERROR on error. +*/ + +sword OCITypeAddAttr(OCISvcCtx *svchp, OCIError *errhp, OCIType *type, + const oratext *a_name, ub4 a_length, + OCIParam *attr_info); +/* + NAME: OCITypeAddAttr - OCI Type Add Attribute to an Object Type. + REMARKS: + Adds an attribute to an Object type (that was constructed earlier with + typecode OCI_TYPECODE_OBJECT). + PARAMETERS: + svchp (IN) - The OCI Service Context + errhp (IN/OUT) - The OCI error handle. If there is an error, it is + recorded in errhp and this function returns + OCI_ERROR. Diagnostic information can be obtained by + calling OCIErrorGet(). + type (IN/OUT) - The Type description that is being constructed. + a_name(IN) - Optional. gives the name of the attribute. + a_length - Optional. gives length of attribute name. + attr_info - Information on the attribute. It is obtained by + allocating an OCIParam (parameter handle) and setting + type information in the OCIParam using OCIAttrSet() + calls. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_ERROR on error. +*/ + +sword OCITypeEndCreate(OCISvcCtx *svchp, OCIError *errhp, OCIType *type); +/* + NAME: OCITypeEndCreate - OCI Type End Creation + REMARKS: + Finishes construction of a type description.Subsequently, only access + will be allowed. + PARAMETERS: + svchp (IN) - The OCI Service Context + errhp (IN/OUT) - The OCI error handle. If there is an error, it is + recorded in errhp and this function returns + OCI_ERROR. Diagnostic information can be obtained by + calling OCIErrorGet(). + type (IN/OUT) - The Type description that is being constructed. + RETURNS: + OCI_SUCCESS if the function completes successfully. + OCI_ERROR on error. +*/ + +/*=========================*/ +/* PUBLIC MACROS AND FLAGS */ +/*=========================*/ + +/*--------------------------------------------------------------------------*/ +/* TYPE ELEMENT FLAGS */ +/*--------------------------------------------------------------------------*/ + +#define OCI_TYPEELEM_REF 0x8000 /* element is a REF */ +#define OCI_TYPEPARAM_REQUIRED 0x0800 /* parameter is required */ + +/* macros to test flags */ +#define OCI_TYPEELEM_IS_REF(elem_flag) \ + (((elem_flag) & OCI_TYPEELEM_REF)!=0) +#define OCI_TYPEPARAM_IS_REQUIRED(param_flag) \ + (((param_flag) & OCI_TYPEPARAM_REQUIRED)!=0) + + +#endif /* ORT_ORACLE */ + diff --git a/OCI/include/xa.h b/OCI/include/xa.h new file mode 100644 index 0000000..9dcd519 --- /dev/null +++ b/OCI/include/xa.h @@ -0,0 +1,200 @@ +/* Copyright (c) 1992, 2006, Oracle. All rights reserved. */ + +/* + NAME + xa.h - + DESCRIPTION + + PUBLIC FUNCTION(S) + + PRIVATE FUNCTION(S) + + RETURNS + + NOTES + + + This is the public XA .h file + + MODIFIED (MM/DD/YY) + yohu 08/27/06 - XA/RAC project changes: XAER_AFFINITY + dmukhin 06/29/05 - ANSI prototypes; miscellaneous cleanup + whe 09/01/99 - 976457:check __cplusplus for C++ code + ntang 10/20/98 - Remove TMCACHE & TMFORCL + abhide 08/04/97 - implement xaoforcl + abhide 07/23/97 - XA OTS project changes + schandra 02/20/96 - lint + abhide 04/07/94 - merge changes from branch 1.1.710.1 + abhide 02/14/94 - Creation + abhide 02/10/94 - Creation + abhide 02/10/94 - Creation +*/ +/* + * xa.h header + * Typed in from X/Open doc of March 13, 1990 + * Updated to Parsippany II draft, March, 1991 + * Updated to Co Review draft, 19 Sep 1991 + */ + +#ifndef XA_H +#define XA_H + + +/* + * Transaction branch identification: XID and NULLXID: + */ + + +#define XIDDATASIZE 128 /* size in bytes */ +#define MAXGTRIDSIZE 64 /* maximum size in bytes of gtrid */ +#define MAXBQUALSIZE 64 /* maximum size in bytes of bqual */ +struct xid_t { + long formatID; /* format identifier */ + long gtrid_length; /* value from 1 through 64 */ + long bqual_length; /* value from 1 through 64 */ + char data[XIDDATASIZE]; +}; +typedef struct xid_t XID; + +/* + * A value of -1 in formatID means that the XID is null. + */ +/* + * Declarations of routines by which RMs call TMs: + */ + +int ax_reg(int, XID *, long); +int ax_unreg(int, long); +/* + * XA Switch Data Structure + */ +#define RMNAMESZ 32 /* length of resource manager name, */ + /* including the null terminator */ +#define MAXINFOSIZE 256 /* maximum size in bytes of xa_info strings, */ + /* including the null terminator */ +struct xa_switch_t { + char name[RMNAMESZ]; /* name of resource manager */ + long flags; /* resource manager specific options */ + long version; /* must be 0 */ + + int (*xa_open_entry)(char *, int, long); /*xa_open function pointer*/ + int (*xa_close_entry)(char *, int, long); /*xa_close function pointer*/ + int (*xa_start_entry)(XID *, int, long); /*xa_start function pointer*/ + int (*xa_end_entry)(XID *, int, long); /*xa_end function pointer*/ + int (*xa_rollback_entry)(XID *, int, long); + /*xa_rollback function pointer*/ + int (*xa_prepare_entry)(XID *, int, long); /*xa_prepare function pointer*/ + int (*xa_commit_entry)(XID *, int, long); /*xa_commit function pointer*/ + int (*xa_recover_entry)(XID *, long, int, long); + /*xa_recover function pointer*/ + int (*xa_forget_entry)(XID *, int, long); /*xa_forget function pointer*/ + int (*xa_complete_entry)(int *, int *, int, long); +}; + +/* + * Flag definition for the RM switch + */ +#define TMNOFLAGS 0x00000000L /* no resource manager features + selected */ +#define TMREGISTER 0x00000001L /* resource manager dynamically + registers */ +#define TMNOMIGRATE 0x00000002L /* resource manager does not support + association migration */ +#define TMUSEASYNC 0x00000004L /* resource manager supports + asynchronous operations */ +/* + * Flag definitions for xa_ and ax_ routines + */ +/* Use TMNOFLAGS, defined above, when not specifying other flags */ +#define TMASYNC 0x80000000L /* perform routine asynchronously */ +#define TMONEPHASE 0x40000000L /* caller is using one-phase commit + optimisation */ +#define TMFAIL 0x20000000L /* dissociates caller and marks + transaction branch rollback-only */ +#define TMNOWAIT 0x10000000L /* return if blocking condition + exists */ +#define TMRESUME 0x08000000L /* caller is resuming association + with suspended transaction branch */ +#define TMSUCCESS 0x04000000L /* dissociate caller from transaction + branch */ +#define TMSUSPEND 0x02000000L /* caller is suspending, not ending, + association */ +#define TMSTARTRSCAN 0x01000000L /* start a recovery scan */ +#define TMENDRSCAN 0x00800000L /* end a recovery scan */ +#define TMMULTIPLE 0x00400000L /* wait for any asynchronous + operation */ +#define TMJOIN 0x00200000L /* caller is joining existing + transaction branch */ +#define TMMIGRATE 0x00100000L /* caller intends to perform + migration */ + +/* + * ax_() return codes (transaction manager reports to resource manager) + */ +#define TM_JOIN 2 /* caller is joining existing transaction + branch */ +#define TM_RESUME 1 /* caller is resuming association with + suspended transaction branch */ +#define TM_OK 0 /* normal execution */ +#define TMER_TMERR -1 /* an error occurred in the transaction + manager */ +#define TMER_INVAL -2 /* invalid arguments were given */ +#define TMER_PROTO -3 /* routine invoked in an improper context */ + +/* + * xa_() return codes (resource manager reports to transaction manager) + */ +#define XA_RBBASE 100 /* The inclusive lower bound of the + rollback codes */ +#define XA_RBROLLBACK XA_RBBASE /* The rollback was caused by an + unspecified reason */ +#define XA_RBCOMMFAIL XA_RBBASE+1 /* The rollback was caused by a + communication failure */ +#define XA_RBDEADLOCK XA_RBBASE+2 /* A deadlock was detected */ +#define XA_RBINTEGRITY XA_RBBASE+3 /* A condition that violates the + integrity of the resources was + detected */ +#define XA_RBOTHER XA_RBBASE+4 /* The resource manager rolled back the + transaction for a reason not on this + list */ +#define XA_RBPROTO XA_RBBASE+5 /* A protocal error occurred in the + resource manager */ +#define XA_RBTIMEOUT XA_RBBASE+6 /* A transaction branch took too long*/ +#define XA_RBTRANSIENT XA_RBBASE+7 /* May retry the transaction branch */ +#define XA_RBEND XA_RBTRANSIENT /* The inclusive upper bound of the + rollback codes */ + +#define XA_NOMIGRATE 9 /* resumption must occur where + suspension occurred */ +#define XA_HEURHAZ 8 /* the transaction branch may have been + heuristically completed */ +#define XA_HEURCOM 7 /* the transaction branch has been + heuristically comitted */ +#define XA_HEURRB 6 /* the transaction branch has been + heuristically rolled back */ +#define XA_HEURMIX 5 /* the transaction branch has been + heuristically committed and rolled + back */ +#define XA_RETRY 4 /* routine returned with no effect + and may be re-issued */ +#define XA_RDONLY 3 /* the transaction was read-only + and has been committed */ +#define XA_OK 0 /* normal execution */ +#define XAER_ASYNC -2 /* asynchronous operation already + outstanding */ +#define XAER_RMERR -3 /* a resource manager error occurred + in the transaction branch */ +#define XAER_NOTA -4 /* the XID is not valid */ +#define XAER_INVAL -5 /* invalid arguments were given */ +#define XAER_PROTO -6 /* routine invoked in an improper + context */ +#define XAER_RMFAIL -7 /* resource manager unavailable */ +#define XAER_DUPID -8 /* the XID already exists */ +#define XAER_OUTSIDE -9 /* resource manager doing work */ + /* outside global transaction */ + +#define XAER_AFFINITY -10 /* XA on RAC: resumption must occur on + RAC instance where the transaction + branch was created */ + +#endif /* ifndef XA_H */ diff --git a/OCI/lib/MSVC/vc8/oraocci11.sym b/OCI/lib/MSVC/vc8/oraocci11.sym new file mode 100644 index 0000000000000000000000000000000000000000..237f3f3f1446b3a9c9869ea0379d54e39d8ae7df GIT binary patch literal 1137728 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νNbcAikz?SJVu`HKF@ZzTEDuTZ|N;RUl}+y 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 literal 0 HcmV?d00001 diff --git a/OCI/lib/MSVC/vc8/oraocci11d.sym b/OCI/lib/MSVC/vc8/oraocci11d.sym new file mode 100644 index 0000000000000000000000000000000000000000..e9af417ac995a8c183437d34cfb6a6972a021563 GIT binary patch literal 1589568 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�G zQSi5FOxJFAJmPc5gOQ-NdVUC=@uj+M_wnbbJ0H$y^u*mh9b?4Da2gQoTavdA`q-5C zaYtNk9{Lfl5r=1;L6Xs+K?u^(THT9r|DiVvnxDi0KnI^%HeB`87}59(G-%BJ9!$Q^ zxJ73?dkEqGanwD3oj(nG&$H(KK{KH@)vLZX7DU#E#Zz4X8+4p!FzxfuYeBI=CvkrV zC2Ilq4)7*pQu-S4n~ZB?NMjg0RY9#W9X!8O0iZ<#cMUd=Q#$On9&){FJO=$Lpc-TH zn<|Jx<0be}sr{@!;A2_osLCo}LMk_&20!REiwYwOK?#06PzFwKIC<&S1GCY4{NG|W ze;NeCTCi-eF4qQ){I93sxK|%~?;6kJ@gsdDz(qYWxIDQPv#-JUsYY-#Ui#iejR1)s zbq<&P;SW0NqoDIi63p$bC|?q=;-GCskxw?h#UoUWkud%w)^z0GY|fu1X#V!4@xK4k zn|A5g@WFi6{7pCkbO-@XVPqGMemiJN-=O znuDIHS??JDxc|&7?F<+OIV1B~JiR#!6yuXHpT&U{&=V6!^Ir1LNGGo#Oaz$W8Cgt) zF^r8r5m;f+=CH&22)=~}&+TFV;^_~i5R8pK7w}SDg)~UJNf}>ZTDkfW@Z&q^NqXX- zPrPvjatM5qw?mWgQe)%xiMw`LjR^?1PuRtBw&waNyEe`?3Rk{z`{Z4U%;sqCjN&IW k<^GbR)(MRagt@&re->r+_1#~WCzrn*5y=1V|DiwsKQ*a;UH||9 literal 0 HcmV?d00001 diff --git a/OCI/lib/MSVC/vc9/oraocci11.sym b/OCI/lib/MSVC/vc9/oraocci11.sym new file mode 100644 index 0000000000000000000000000000000000000000..7e616520662fba5447a72143544577f9e8b7ce17 GIT binary patch literal 1417200 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ƖlA< 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

h08BTJ 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 literal 0 HcmV?d00001 diff --git a/OCI/lib/MSVC/vc9/oraocci11d.sym b/OCI/lib/MSVC/vc9/oraocci11d.sym new file mode 100644 index 0000000000000000000000000000000000000000..b2240bc95e92487623ada64b3bf16f2bd1630773 GIT binary patch literal 3037456 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 J@Be{6{{b*w#7+PJ literal 0 HcmV?d00001 diff --git a/README.md b/README.md new file mode 100644 index 0000000..2c060b9 --- /dev/null +++ b/README.md @@ -0,0 +1,6 @@ +# ITK + +ITK模板 + +VisualStudio版本: 2015 +