PolarDB：OCI

Unduh driver PolarDB OCI

polardb-oci.tar.gz

Instal driver PolarDB OCI

Dekompresi paket driver dan impor file driver ke variabel lingkungan. Hal ini memungkinkan Anda menemukan lokasi driver yang benar saat mengkompilasi demo.

Anda dapat menggunakan metode berikut untuk secara manual mengimpor file driver ke variabel lingkungan di Linux dan Windows:

• Linux
  1. Salin file libpolaroci.so.10.2, libiconv.so.2, dan libpq.so.5.11 ke direktori /usr/lib.
  2. Buat tautan simbolik.

     ln -s /usr/lib/libpolaroci.so.10.2 /usr/lib/libpolaroci.so
     ln -s /usr/lib/libiconv.so.2 /usr/lib/libiconv.so
     ln -s /usr/lib/libpq.so.5.11 /usr/lib/libpq.so
     ln -s /usr/lib/libpq.so.5.11 /usr/lib/libpq.so.5

  3. Setel variabel lingkungan di Linux.

     export LD_LIBRARY_PATH=/usr/lib

  Catatan

  • Jika file libiconv.so sudah ada di sistem Anda, Anda dapat langsung menggunakan file tersebut. Anda juga dapat mengikuti petunjuk dalam dokumentasi libiconv untuk mengunduh, mengompilasi, dan menginstal libiconv, lalu menggunakan file .so yang telah dikompilasi.
  • Di Linux, file libiconv.so yang disediakan oleh driver OCI PolarDB for PostgreSQL (Kompatibel dengan Oracle) hanya untuk referensi.
• Windows
  1. Setel variabel lingkungan.

     Editor IDE di Windows umumnya mampu mengimpor jalur file yang ditautkan. Dalam topik ini, Visual Studio digunakan untuk menggambarkan cara mengimpor jalur file yang ditautkan, seperti yang ditunjukkan pada gambar berikut.

     
  2. Pada tab properti proyek, tambahkan direktori pustaka tambahan. Lalu, tambahkan file .dll di direktori driver ke Additional Library Directories.

Tulis kode

Contoh kode berikut menunjukkan cara menulis kode. Demo polardb_demo di direktori sample digunakan dalam contoh.

/* ============================================================================
 * Copyright (c) 2004-2019 POLARDB Corporation. All Rights Reserved.
 * ===========================================================================
 */
#include <stdio.h>
#include <stdlib.h>

#include <string.h>
#include <oci.h>

#ifdef WIN32
#include <time.h>
#else
#include <sys/time.h>
#endif

/* Definisikan makro untuk menangani kesalahan */
#define HANDLE_ERROR(x,y) check_oci_error(x,y)

#define DATE_FMT "DAY, MONTH DD, YYYY"
#define DATE_LANG "American"

sword ConvertStringToDATE( char *datep, char *formatp, dvoid *datepp );
/* Rutin Kustom untuk menangani kesalahan,     */

/* ini mendemonstrasikan Penanganan Kesalahan/Pengecualian di OCI */
void check_oci_error (dvoid * errhp, sword status);

/*
 * <<<<<<<<<<<<<<<<<<< PROTOTIPE FUNGSI<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
 */

/* Inisialisasi    & Alokasikan semua handle */
void
initHandles (OCISvcCtx **, OCIServer **, OCISession **, OCIError **,
         OCIEnv **);

/* masuk ke database dan mulai sesi pengguna */
void
logon (OCISvcCtx **, OCIServer **, OCISession **, OCIError **,
       OCIEnv **, text *, text *, text *);

/* Buat tabel yang diperlukan  */
void create_table (OCISvcCtx *, OCIError *, OCIEnv *);

/* siapkan data untuk contoh kita */
void prepare_data (OCISvcCtx *, OCIError *, OCIEnv *);

/* buat prosedur/fungsi untuk didemonstrasikan dalam contoh */
void create_stored_procs (OCISvcCtx *, OCIError *, OCIEnv *);

/* pilih dan cetak data dengan mengulangi melalui resultSet */
void select_print_data (OCISvcCtx *, OCIError *, OCIEnv *);

/* demonstrasikan pemanggilan prosedur tersimpan dan pengambilan nilai */

/* proc1 mendemonstrasikan IN OUT */
void call_stored_proc1 (OCISvcCtx *, OCIError *, OCIEnv *);

/* proc2 mendemonstrasikan OUT */
void call_stored_proc2 (OCISvcCtx *, OCIError *, OCIEnv *);

/* hapus tabel yang diperlukan */
void drop_table (OCISvcCtx *, OCIError *, OCIEnv *);

/* hapus prosedur tersimpan dan fungsi */
void drop_stored_procs (OCISvcCtx *, OCIError *, OCIEnv *);

/* bersihkan handle utama sebelum keluar */
void
cleanup (OCISvcCtx **, OCIServer **, OCISession **, OCIError **, OCIEnv **);

/*
 * <<<<<<<<<<<<<<<<<<<<<<<<< AKHIR DARI PROTOYPE FUNGSI<<<<<<<<<<<<<<<<<<<<<<<<<<
 */


/* <<<<<<<<<< Variabel Global */
ub4 init_mode = OCI_DEFAULT;
ub4 auth_mode = OCI_CRED_RDBMS;

/* <<<<<<<<<< Akhir Variabel Global */

int
main (void)
{

  /*
   * Deklarasikan Handle, program OCI tipikal setidaknya membutuhkan
   * handle berikut Enviroment Handle Error Handle Service Context
   * Handle Server Handle User Session (Authentication Handle)
   */

  /* Enviroment */
  OCIEnv *envhp;

  /* Error */
  OCIError *errhp;

  /* Service Context */
  OCISvcCtx *svchp;

  /* Server */
  OCIServer *srvhp;

  /* Session(authentication) */
  OCISession *authp;


  /*
   * Akhir deklarasi Handle
   */

  /*
   * Deklarasikan variabel lokal,
   */
  text *username = (text *) "parallels";
  text *passwd = (text *) "";

  /*
   * Oracle Instant Client Connection String
   */
  text *server = (text *) "//localhost:5432/postgres";

  /*
   * Inisialisasi dan Alokasikan handle
   */
  initHandles (&svchp, &srvhp, &authp, &errhp, &envhp);

  /*
   * masuk ke database
   */
  logon (&svchp, &srvhp, &authp, &errhp, &envhp, username, passwd, server);

  /*
   * Buat tabel yang diperlukan untuk contoh ini
   */
  create_table (svchp, errhp, envhp);

  /*
   * sisipkan data ke dalam tabel
   */
  prepare_data (svchp, errhp, envhp);

  /*
   * buat prosedur tersimpan & fungsi
   */
  create_stored_procs (svchp, errhp, envhp);

  /*
   * pilih dan cetak data dengan mengulangi melalui simple resultSet
   */
  select_print_data (svchp, errhp, envhp);

  /*
   * demonstrasikan pemanggilan prosedur tersimpan dan pengambilan nilai
   */
  call_stored_proc1 (svchp, errhp, envhp);

  /*
   * demonstrasikan parameter OUT
   */
  call_stored_proc2 (svchp, errhp, envhp);

  /*
   * Hapus tabel yang digunakan dalam contoh ini
   */
  drop_table (svchp, errhp, envhp);

  /*
   * Hapus prosedur tersimpan & fungsi yang digunakan dalam contoh ini
   */
  drop_stored_procs (svchp, errhp, envhp);

  /*
   * bersihkan sumber daya
   */
  cleanup (&svchp, &srvhp, &authp, &errhp, &envhp);

  return 0;
}

/* Rutin Kustom untuk menangani kesalahan,     */

/* ini mendemonstrasikan Penanganan Kesalahan/Pengecualian di OCI */

void
check_oci_error (dvoid * errhp, sword status)
{
  text errbuf[512];
  sb4 errcode;

  if (status == OCI_SUCCESS)
    {
      return;
    }
  switch (status)
    {
    case OCI_SUCCESS_WITH_INFO:
      printf ("OCI_SUCCESS_WITH_INFO:\n");
      OCIErrorGet (errhp, (ub4) 1, (text *) 0, &errcode,
           errbuf, (ub4) sizeof (errbuf), OCI_HTYPE_ERROR);
      printf ("%s", errbuf);
      break;
    case OCI_NEED_DATA:
      printf ("Kesalahan - OCI_NEED_DATA\n");
      break;
    case OCI_NO_DATA:
      printf ("Kesalahan - OCI_NO_DATA\n");
      break;
    case OCI_ERROR:
      printf ("Kesalahan - OCI_ERROR:\n");
      OCIErrorGet (errhp, (ub4) 1, (text *) 0, &errcode,
           errbuf, (ub4) sizeof (errbuf), OCI_HTYPE_ERROR);
      printf ("%s", errbuf);
      break;
    case OCI_INVALID_HANDLE:
      printf ("Kesalahan - OCI_INVALID_HANDLE\n");
      break;
    case OCI_STILL_EXECUTING:
      printf ("Kesalahan - OCI_STILL_EXECUTING\n");
      break;
    case OCI_CONTINUE:
      printf ("Kesalahan - OCI_CONTINUE\n");
      break;
    default:
      break;
    }

  /*
   * keluar aplikasi
   */
  exit((int)status);
}

/* Inisialisasi & Alokasikan handle yang diperlukan */
void
initHandles (OCISvcCtx ** svchp, OCIServer ** srvhp, OCISession ** authp,
         OCIError ** errhp, OCIEnv ** envhp)
{

  /*
   * Sekarang Mulai Bagian di mana kita harus menginisialisasi & Mengalokasikan
   * handle dasar. Ini adalah setup atau inisialisasi wajib yang
   * diperlukan sebelum kita dapat melanjutkan untuk masuk dan bekerja dengan
   * database. Inisialisasi dan persiapan ini akan mencakup langkah-langkah berikut
   *
   * 1. Inisialisasi OCI (OCIInitialize()) 2. Inisialisasi
   * Lingkungan (OCIEnvInit()) 3. Inisialisasi & Alokasikan Handle Kesalahan
   * 4. Inisialisasi & Alokasikan Handle Konteks Layanan 5. Inisialisasi &
   * Alokasikan Handle Sesi 6. Inisialisasi & Alokasikan Handle Server
   *
   * Menurut versi baru OCI , sebagai ganti menggunakan OCIInitialize()
   * dan OCIEnvInit(), kita dapat melakukannya dengan satu panggilan API yang disebut
   * OCIEnvCreate().
   */

  /*
   * Inisialisasi OCI
   */
  if (OCIInitialize (init_mode, (dvoid *) 0,
             (dvoid * (*)(dvoid *, size_t)) 0,
             (dvoid * (*)(dvoid *, dvoid *, size_t)) 0,
             (void (*)(dvoid *, dvoid *)) 0) != OCI_SUCCESS)
    {
      printf ("ERROR: gagal menginisialisasi OCI\n");
      exit (1);
    }
  /*
   * Inisialisasi Lingkungan.
   */
  HANDLE_ERROR (*envhp,
        OCIEnvInit (&(*envhp), OCI_DEFAULT, (size_t) 0,
                (dvoid **) 0));

  /*
   * Inisialisasi & Alokasikan Handle Kesalahan
   */
  HANDLE_ERROR (*envhp,
        OCIHandleAlloc (*envhp, (dvoid **) & (*errhp),
                OCI_HTYPE_ERROR, (size_t) 0, (dvoid **) 0));

  /*
   * Inisialisasi & Alokasikan Handle Konteks Layanan
   */
  HANDLE_ERROR (*errhp,
        OCIHandleAlloc (*envhp, (dvoid **) & (*svchp),
                OCI_HTYPE_SVCCTX, (size_t) 0, (dvoid **) 0));

  /*
   * Inisialisasi & Alokasikan Handle Sesi
   */
  HANDLE_ERROR (*errhp,
        OCIHandleAlloc (*envhp, (dvoid **) & (*authp),
                OCI_HTYPE_SESSION, (size_t) 0, (dvoid **) 0));

  /*
   * Inisialisasi & Alokasikan Handle Server
   */
  HANDLE_ERROR (*errhp,
        OCIHandleAlloc (*envhp, (dvoid **) & (*srvhp),
                OCI_HTYPE_SERVER, (size_t) 0, (dvoid **) 0));

}

void
logon (OCISvcCtx ** svchp, OCIServer ** srvhp, OCISession ** authp,
       OCIError ** errhp, OCIEnv ** envhp, text * username, text * passwd,
       text * server)
{

  /*
   * Sekarang Mulai Masuk kami ke Server Database yang mencakup dua
   * langkah
   *
   * 1. Lampirkan ke Server 2. Mulai atau Awali Sesi
   *
   * Ini adalah masuk kompleks. Cara mudah untuk masuk adalah dengan menghindari
   * lampiran server dan awal sesi dan cukup gunakan OCILogon() atau
   * OCILogon2() lalu keluar menggunakan OCILogoff()
   */

  /*
   * Lampirkan ke server
   */

  HANDLE_ERROR (*errhp,
        OCIServerAttach (*srvhp, *errhp, server,
                 (ub4) strlen ((char *) server),
                 OCI_DEFAULT));

  /*
   * Kode berikut akan memulai sesi tetapi sebelum kita memulai sesi
   * kita harus 1. Setel Handle Server yang sekarang dilampirkan
   * ke Handle Konteks Layanan 2. Setel Nama Pengguna dan kata sandi ke
   * Handle Sesi
   */

  /*
   * Setel Handle Server ke Handle Konteks Layanan
   */

  HANDLE_ERROR (*errhp,
        OCIAttrSet (*svchp, OCI_HTYPE_SVCCTX,
                (dvoid *) (*srvhp), (ub4) 0, OCI_ATTR_SERVER,
                *errhp));

  /*
   * Setel nama pengguna dan kata sandi ke handle sesi
   */

  HANDLE_ERROR (*errhp,
        OCIAttrSet (*authp, OCI_HTYPE_SESSION,
                (dvoid *) username,
                (ub4) strlen ((char *) username),
                OCI_ATTR_USERNAME, *errhp));
  HANDLE_ERROR (*errhp,
        OCIAttrSet (*authp, OCI_HTYPE_SESSION, (dvoid *) passwd,
                (ub4) strlen ((char *) passwd), OCI_ATTR_PASSWORD,
                *errhp));

  /*
   * Sekarang AKHIRNYA Mulai sesi kami
   */

  HANDLE_ERROR ((*errhp),
        OCISessionBegin (*svchp, *errhp,
                 *authp, auth_mode, OCI_DEFAULT));

  printf ("********************************************\n");
  printf ("Tonggak Sejarah  : Masuk sebagai --> '%s'\n", username);
  printf ("********************************************\n");

  /*
   * Setelah kita Memulai sesi kita, kita harus menyetel Sesi
   */

  /*
   * (otentikasi) handle ke Handle Konteks Layanan
   */

  HANDLE_ERROR (*errhp,
        OCIAttrSet (*svchp, OCI_HTYPE_SVCCTX,
                (dvoid *) (*authp), (ub4) 0,
                OCI_ATTR_SESSION, *errhp));
}

/* Buat tabel yang diperlukan untuk contoh ini */
void
create_table (OCISvcCtx * svchp, OCIError * errhp, OCIEnv * envhp)
{
  OCIStmt *stmhp;
  text *create_statement =
    (text *)"CREATE TABLE OCISPEC \n (ENAME VARCHAR2(20)\n, MGR NUMBER\n, HIREDATE DATE)";
  ub4 status = OCI_SUCCESS;

  /*
   * Inisialisasi & Alokasikan Handle Pernyataan
   */
  HANDLE_ERROR (errhp,
        OCIHandleAlloc (envhp, (dvoid **) & stmhp,
                OCI_HTYPE_STMT, (size_t) 0, (dvoid **) 0));


  /*
   * Persiapkan pernyataan Create
   */

  HANDLE_ERROR (errhp,
        OCIStmtPrepare (stmhp, errhp,
                create_statement,
                strlen ((const char *) create_statement),
                OCI_NTV_SYNTAX, OCI_DEFAULT));


  /*
   * Eksekusi pernyataan Create
   */
  if ((status = OCIStmtExecute (svchp, stmhp, errhp,
                   (ub4) 1, (ub4) 0, NULL, NULL, OCI_DEFAULT)) < OCI_SUCCESS)
    {
      printf ("KEGAGALAN DALAM MEMBUAT TABEL\n");
      HANDLE_ERROR (errhp, status);
      return;
    }
  else
    {
      printf ("********************************************\n");
      printf ("Tonggak Sejarah : Tabel berhasil dibuat\n");
      printf ("********************************************\n");
    }
  HANDLE_ERROR (errhp, OCIHandleFree (stmhp, OCI_HTYPE_STMT));
}

/* siapkan data untuk contoh kita */
void
prepare_data (OCISvcCtx * svchp, OCIError * errhp, OCIEnv * envhp)
{
  OCIStmt *stmhp;
  text *insstmt =
    (text *)
    "INSERT INTO OCISPEC (ename,mgr, hiredate) VALUES (:ENAME,:MGR, CAST(:HIREDATE AS timestamp))";
  OCIBind *bnd1p = (OCIBind *) 0;    /* handle bind pertama   */
  OCIBind *bnd2p = (OCIBind *) 0;    /* handle bind kedua */
  OCIBind *bnd3p = (OCIBind *) 0;    /* handle bind ketiga   */
  ub4 status = OCI_SUCCESS;
  int i = 0;

  char *ename[3] = { "SMITH", "ALLEN", "KING" };

  sword mgr[] = { 7886, 7110, 7221 };

  char *date_buffer[3] = { "02-AUG-07", "02-APR-07", "02-MAR-07" };

  /*
   * Inisialisasi & Alokasikan Handle Pernyataan
   */
  HANDLE_ERROR (errhp,
        OCIHandleAlloc (envhp, (dvoid **) & stmhp,
                OCI_HTYPE_STMT, (size_t) 0, (dvoid **) 0));

  /*
   * Persiapkan pernyataan insert
   */
  HANDLE_ERROR (errhp,
        OCIStmtPrepare (stmhp, errhp, insstmt,
                (ub4) strlen ((char *) insstmt),
                (ub4) OCI_NTV_SYNTAX, (ub4) OCI_DEFAULT));

  /*
   * Dalam loop ini kita akan mengikat data dari array untuk menyisipkan multi
   * baris ke dalam database cara yang lebih elegan dan lebih baik untuk melakukannya adalah
   * menggunakan Pengikatan Array (Penyisipan Batch). POLARDB OCI Replacement
   * Library AKAN mendukung Pengikatan Array meskipun tidak digunakan di sini
   * saat ini
   */
  for (i = 0; i < 3; i++)
    {
      /*
       * Variabel Bind untuk ENAME
       */
      HANDLE_ERROR (errhp,
            OCIBindByName (stmhp, &bnd1p, errhp, (text *) ":ENAME",
                   -1, (dvoid *) ename[i],
                   (sb4) strlen (ename[i]) + 1, SQLT_STR,
                   (dvoid *) 0, 0, (ub2 *) 0, (ub4) 0,
                   (ub4 *) 0, OCI_DEFAULT));

      /*
       * Variabel Bind untuk MGR
       */
      HANDLE_ERROR (errhp,
            OCIBindByName (stmhp, &bnd2p, errhp, (text *) ":MGR",
                   -1, (dvoid *) & mgr[i], sizeof (mgr[i]),
                   SQLT_INT, (dvoid *) 0, 0, (ub2 *) 0,
                   (ub4) 0, (ub4 *) 0, OCI_DEFAULT));

      /*
       * Variabel Bind untuk HIREDATE
       */
      HANDLE_ERROR (errhp,
            OCIBindByName (stmhp, &bnd3p, errhp, (text *) ":HIREDATE",
                   -1, (dvoid *)  date_buffer[i],
                   strlen(date_buffer[i])+1, SQLT_STR, (dvoid *) 0, 0,
                   (ub2 *) 0, (ub4) 0, (ub4 *) 0,
                   OCI_DEFAULT));

      /*
       * Eksekusi pernyataan dan sisipkan data
       */
      if ((status = OCIStmtExecute (svchp, stmhp, errhp,
                   (ub4) 1, (ub4) 0, NULL, NULL, OCI_DEFAULT)) < OCI_SUCCESS)
    {
      printf ("KEGAGALAN DALAM MENYISIPKAN DATA\n");
      HANDLE_ERROR (errhp, status);
      return;
    }
    }

  OCITransCommit (svchp, errhp, (ub4) 0);
  printf ("********************************************\n");
  printf
    ("Tonggak Sejarah : Data berhasil dimasukkan \n & Dikomit melalui Transaksi\n");
  printf ("********************************************\n");
  HANDLE_ERROR (errhp, OCIHandleFree (stmhp, OCI_HTYPE_STMT));

}

/* Buat Prosedur tersimpan dan fungsi yang akan digunakan dalam contoh ini */
void
create_stored_procs (OCISvcCtx * svchp, OCIError * errhp, OCIEnv * envhp)
{
  /*
   * Fungsi ini membuat 2 prosedur tersimpan dan satu fungsi tersimpan
   * 1. StoredProcedureSample1 - untuk menunjukkan eksekusi prosedur dan
   * menerima nilai dari parameter IN OUT 2.
   * StoredProcedureSample2 - untuk menunjukkan eksekusi prosedur dan
   * menerima nilai dari parameter OUT 3. StoredProcedureSample3 -
   * untuk menunjukkan eksekusi fungsi dan menerima nilai
   * yang dikembalikan oleh fungsi dalam cara Pernyataan Callable
   */
  OCIStmt *stmhp;
  OCIStmt *stmhp2;
  OCIStmt *stmhp3;

  text *create_statement =
    (text *)"CREATE OR REPLACE PROCEDURE StoredProcedureSample1\n (mgr1 int, ename1 IN OUT varchar2)\n   is\nbegin\ninsert into ocispec (mgr, ename) values (7990,'STOR1');\nename1 := 'Successful';\n end;\n";

  text *create_statement2 =
    (text *)"CREATE OR REPLACE PROCEDURE StoredProcedureSample2\n(mgr1 int, ename1 varchar2,eout1 OUT varchar2)\nis\nbegin\ninsert into ocispec(mgr,ename) values (7991, 'STOR2');\neout1 := 'Successful';\n    end;";

  text *create_statement3 =
    (text *)"CREATE OR REPLACE FUNCTION f1\nRETURN VARCHAR2\nis\nv_Sysdate DATE;\nv_charSysdate VARCHAR2(20);\nbegin\nSELECT TO_CHAR(SYSDATE, 'dd-mon-yyyy') into v_charSysdate FROM DUAL;\n    return(v_charSysdate);\nend;";



  ub4 status = OCI_SUCCESS;

  /*
   * Inisialisasi & Alokasikan Handle Pernyataan
   */
  HANDLE_ERROR (errhp,
        OCIHandleAlloc (envhp, (dvoid **) & stmhp,
                OCI_HTYPE_STMT, (size_t) 0, (dvoid **) 0));
  HANDLE_ERROR (errhp,
        OCIHandleAlloc (envhp, (dvoid **) & stmhp2,
                OCI_HTYPE_STMT, (size_t) 0, (dvoid **) 0));
  HANDLE_ERROR (errhp,
        OCIHandleAlloc (envhp, (dvoid **) & stmhp3,
                OCI_HTYPE_STMT, (size_t) 0, (dvoid **) 0));

  /*
   * Persiapkan pernyataan Create
   */

  HANDLE_ERROR (errhp,
        OCIStmtPrepare (stmhp, errhp,
                create_statement,
                strlen ((const char *) create_statement),
                OCI_NTV_SYNTAX, OCI_DEFAULT));
  HANDLE_ERROR (errhp,
        OCIStmtPrepare (stmhp2, errhp, create_statement2,
                strlen ((const char *) create_statement2),
                OCI_NTV_SYNTAX, OCI_DEFAULT));
  HANDLE_ERROR (errhp,
        OCIStmtPrepare (stmhp3, errhp, create_statement3,
                strlen ((const char *) create_statement3),
                OCI_NTV_SYNTAX, OCI_DEFAULT));

  /*
   * Eksekusi Pernyataan Create SampleProcedure1
   */
  if ((status = OCIStmtExecute (svchp, stmhp, errhp,
                   (ub4) 1, (ub4) 0, NULL, NULL, OCI_DEFAULT)) < OCI_SUCCESS)
    {
      printf ("KEGAGALAN DALAM MEMBUAT PROSEDUR 1\n");
      HANDLE_ERROR (errhp, status);
      return;
    }
  else
    {
      printf ("********************************************\n");
      printf ("Tonggak Sejarah : Contoh Prosedur 1 Berhasil dibuat\n");
      printf ("********************************************\n");

    }

  /*
   * Eksekusi Pernyataan Create Sample Procedure2
   */
  if ((status = OCIStmtExecute (svchp, stmhp2, errhp,
                   (ub4) 1, (ub4) 0, NULL, NULL, OCI_DEFAULT)) < OCI_SUCCESS)
    {
      printf ("KEGAGALAN DALAM MEMBUAT PROSEDUR 2\n");
      HANDLE_ERROR (errhp, status);
      return;
    }
  else
    {
      printf ("********************************************\n");
      printf ("Tonggak Sejarah : Contoh Prosedur 2 Berhasil dibuat\n");
      printf ("********************************************\n");
    }

  /*
   * Eksekusi Pernyataan Create Sample Procedure3
   */
  if ((status = OCIStmtExecute (svchp, stmhp3, errhp,
                   (ub4) 1, (ub4) 0, NULL, NULL, OCI_DEFAULT)) < OCI_SUCCESS)
    {
      printf ("KEGAGALAN DALAM MEMBUAT PROSEDUR 3\n");
      HANDLE_ERROR (errhp, status);
      return;
    }
  else
    {
      printf ("********************************************\n");
      printf ("Tonggak Sejarah : Contoh Prosedur 3 Berhasil dibuat\n");
      printf ("********************************************\n");
    }


  HANDLE_ERROR (errhp, OCIHandleFree (stmhp, OCI_HTYPE_STMT));
  HANDLE_ERROR (errhp, OCIHandleFree (stmhp2, OCI_HTYPE_STMT));
  HANDLE_ERROR (errhp, OCIHandleFree (stmhp3, OCI_HTYPE_STMT));
}

/* pilih dan cetak data dengan mengulangi melalui resultSet */
void
select_print_data (OCISvcCtx * svchp, OCIError * errhp, OCIEnv * envhp)
{

  /* Statement */
  OCIStmt *stmhp;

  /* Define */
  OCIDefine *define;

  /* Buffer untuk nama karyawan */
  char ename_buffer[10] ;

  /* Buffer untuk mgr */
  sword mgr_buffer;

  /*Buffer untuk hiredate */
  char hire_date[20];

  /*
   * pernyataan select sederhana
   */
  text * sql_statement =
      (text *) "select ename,mgr,hiredate from ocispec";

  /*
   * variabel lokal tambahan
   */

  ub4 rows = 1;
  ub4 fetched = 1;
  ub4 status = OCI_SUCCESS;

  sb2 null_ind_ename = 0;

  /* indikator null untuk ename */
  sb2 null_ind_mgr = 0;

  /* indikator null untuk mgr */
  sb2 null_ind_hiredate = 0;

  /* indikator null untuk hiredate */

  /*
   * Sekarang kita akan mulai Tonggak Sejarah dari Query Sederhana dari
   * database dan ulangi melalui resultSet Ini akan mencakup
   * langkah-langkah berikut
   *
   * 1. Inisialisasi dan Alokasikan Handle Pernyataan 2. Persiapkan
   * Pernyataan 3. Definisikan variabel output untuk menerima output dari
   * pernyataan select 4. Eksekusi pernyataan 5. Ambil resultSet
   * dan Cetak nilai
   *
   */
memset( ename_buffer, 0, sizeof(ename_buffer) );
memset( hire_date, 0, sizeof(hire_date) );
  /*
   * Inisialisasi & Alokasikan Handle Pernyataan
   */

  HANDLE_ERROR (errhp,
        OCIHandleAlloc (envhp, (dvoid **) & stmhp,
                OCI_HTYPE_STMT, (size_t) 0, (dvoid   **));
  
  /*
   * Persiapkan pernyataan
   */

  HANDLE_ERROR (errhp,
        OCIStmtPrepare (stmhp, errhp,
                sql_statement,
                strlen ((const char *) sql_statement),
                OCI_NTV_SYNTAX, OCI_DEFAULT));


  /*
   * Ikat variabel String (OCIString) pada posisi 1. Tipe data yang digunakan
   * SQLT_VST
   */
  HANDLE_ERROR (errhp,
        OCIDefineByPos (stmhp, &define, errhp,
                (ub4) 1, ename_buffer, 10,
                (ub2) SQLT_STR, &null_ind_ename, 0, 0,
                OCI_DEFAULT));

  /*
   * Ikat variabel Angka (OCINumber) pada posisi 2. Tipe data yang digunakan
   * SQLT_VNU
   */
  HANDLE_ERROR (errhp,
        OCIDefineByPos (stmhp, &define, errhp,
                (ub4) 2, &mgr_buffer, sizeof (sword),
                (ub2) SQLT_INT, &null_ind_mgr, 0, 0,
                OCI_DEFAULT));

  /*
   * Ikat variabel Tanggal (OCIDate) pada posisi 3. Tipe data yang digunakan
   * SQLT_ODT
   */
  HANDLE_ERROR (errhp,
        OCIDefineByPos (stmhp, &define, errhp,
                (ub4) 3, hire_date, 20,
                (ub2) SQLT_STR, &null_ind_hiredate, 0, 0,
                OCI_DEFAULT));



  /*
   * Eksekusi pernyataan SQL sederhana
   */
  status = OCIStmtExecute (svchp, stmhp, errhp,
               rows, (ub4) 0, NULL, NULL, OCI_DEFAULT);


  /*
   * Cetak resultSet
   */
  if (status == OCI_NO_DATA)
    {
      /*
       * menunjukkan tidak mengambil apa pun (karena kita tidak melakukan pengambilan array)
       */
      fetched = 0;
    }
  else
    {
      HANDLE_ERROR (errhp, status);
    }

  if (fetched)
    {
      /*
       * cetak string
       */
      if (null_ind_ename == -1)
    printf ("name -> [NULL]\t");
      else
    printf ("name -> [%s]\t",  ename_buffer);


      /*
       * cetak angka dengan mengonversinya menjadi int
       */
      if (null_ind_mgr == -1)
    printf ("mgr -> [NULL]\n");
      else
    {
      printf ("mgr -> [%d]\n", mgr_buffer);
    }

      if (null_ind_hiredate == -1)
    printf ("hiredate -> [NULL]\n");
      else
    {
      printf ("hiredate -> [%s]\n",hire_date );
    }

      /*
       * ulangi resultSet satu per satu melalui
       * OCIStmtFetch()
       */

      /*
       * sampai kita tidak menemukan apa pun
       */
      while (1)
    {
      status = OCIStmtFetch (stmhp, errhp,
                 rows, OCI_FETCH_NEXT, OCI_DEFAULT);
      if (status == OCI_NO_DATA)
        {
          /*
           * menunjukkan tidak dapat mengambil apa pun
           */
          break;
        }
      else
        {
          HANDLE_ERROR (errhp, status);
        }

      /*
       * cetak string
       */
      if (null_ind_ename == -1)
        printf ("name -> [NULL]\t");
      else
        printf ("name -> [%s]\t", ename_buffer);

      /*
       * cetak angka dengan mengonversinya menjadi int
       */
      if (null_ind_mgr == -1)
        printf ("mgr -> [NULL]\n");
      else
        {
        printf ("mgr -> [%d]\n", mgr_buffer);
        }

      /*
       * cetak tanggal setelah dikonversi ke teks
       */
      if (null_ind_hiredate == -1)
        printf ("hiredate -> [NULL]\n");
      else
        {

          printf ("hiredate -> [%s]\n", hire_date);
        }
    }
    }
  HANDLE_ERROR (errhp, OCIHandleFree (stmhp, OCI_HTYPE_STMT));

}

void
call_stored_proc1 (OCISvcCtx * svchp, OCIError * errhp, OCIEnv * envhp)
{
  OCIStmt *p_sql;
  OCIBind *p_Bind1 = (OCIBind *) 0;
  OCIBind *p_Bind2 = (OCIBind *) 0;

  char field2[20];


  /*
   * char field3[20];
   */
  sword field1 = 3;
  text *mySql = (text *) "Begin StoredProcedureSample1(:MGR, :ENAME); END";

  memset( field2, 0, sizeof(field2) );
  strcpy( field2, "Entry 3" );

  printf ("*************************************************\n");
  printf ("Contoh 1 - Menggunakan Parameter IN OUT\n");
  printf ("*************************************************\n");


  /*
   * Inisialisasi & Alokasikan Handle Pernyataan
   */

  HANDLE_ERROR (errhp,
        OCIHandleAlloc (envhp, (dvoid **) & p_sql,
                OCI_HTYPE_STMT, (size_t) 0, (dvoid **) 0));

  HANDLE_ERROR (errhp,
        OCIStmtPrepare (p_sql, errhp, mySql,
                (ub4) strlen ((char *)mySql), OCI_NTV_SYNTAX,
                OCI_DEFAULT));

  HANDLE_ERROR (errhp,
        OCIBindByPos (p_sql, &p_Bind1, errhp, 1,
                  (dvoid *) & field1, sizeof (sword),
                  SQLT_INT, 0, 0, 0, 0, 0, OCI_DEFAULT));

  HANDLE_ERROR (errhp,
        OCIBindByPos (p_sql, &p_Bind2, errhp, 2,
                  field2, (sizeof (field2)),
                  SQLT_STR, 0, 0, 0, 0, 0, OCI_DEFAULT));

  printf (" Field2 Sebelum:\n");
  printf (" ukuran ---> %d\n", sizeof (field2));
  printf (" panjang ---> %d\n", strlen (field2));
  printf (" nilai ---> %s\n", field2);

  HANDLE_ERROR (errhp,
        OCIStmtExecute (svchp, p_sql, errhp, (ub4) 1, (ub4) 0,
                (OCISnapshot *) NULL, (OCISnapshot *) NULL,
                (ub4) OCI_COMMIT_ON_SUCCESS));

  printf (" Field2 Setelah:\n");
  printf (" ukuran ---> %d\n", sizeof (field2));
  printf (" panjang ---> %d\n", strlen (field2));
  printf (" nilai ---> %s\n", field2);

  HANDLE_ERROR (errhp, OCIHandleFree (p_sql, OCI_HTYPE_STMT));
}

void
call_stored_proc2 (OCISvcCtx * svchp, OCIError * errhp, OCIEnv * envhp)
{
  OCIStmt *p_sql;
  OCIBind *p_Bind1 = (OCIBind *) 0;
  OCIBind *p_Bind2 = (OCIBind *) 0;
  OCIBind *p_Bind3 = (OCIBind *) 0;

  char field2[20] = "Entry 3";
  char field3[20];
  sword field1 = 3;
  text *mySql =
    (text *) "Begin StoredProcedureSample2(:MGR, :ENAME, :EOUT); END";


  memset( field2, 0, sizeof(field2) );
  strcpy( field2, "Entry 3" );

  memset( field3, 0, sizeof(field3) );


  printf ("*************************************************\n");
  printf ("Contoh 2 - Menggunakan Parameter OUT\n");
  printf ("*************************************************\n");

  /*
   * Inisialisasi & Alokasikan Handle Pernyataan
   */

  HANDLE_ERROR (errhp,
        OCIHandleAlloc (envhp, (dvoid **) & p_sql,
                OCI_HTYPE_STMT, (size_t) 0, (dvoid **) 0));

  HANDLE_ERROR (errhp,
        OCIStmtPrepare (p_sql, errhp, mySql,
                (ub4) strlen ((char *)mySql), OCI_NTV_SYNTAX,
                OCI_DEFAULT));

  HANDLE_ERROR (errhp,
        OCIBindByPos (p_sql, &p_Bind1, errhp, 1,
                  (dvoid *) & field1, sizeof (sword),
                  SQLT_INT, 0, 0, 0, 0, 0, OCI_DEFAULT));

  HANDLE_ERROR (errhp,
        OCIBindByPos (p_sql, &p_Bind2, errhp, 2,
                  field2, strlen (field2) + 1,
                  SQLT_STR, 0, 0, 0, 0, 0, OCI_DEFAULT));

  HANDLE_ERROR (errhp,
        OCIBindByPos (p_sql, &p_Bind3, errhp, 3,
                  field3, 20,
                  SQLT_STR, 0, 0, 0, 0, 0, OCI_DEFAULT));

  printf (" Field3 Sebelum:\n");
  printf (" ukuran ---> %d\n", sizeof (field3));
  printf (" panjang ---> %d\n", strlen (field3));
  printf (" nilai ---> %s\n", field3);

  HANDLE_ERROR (errhp,
        OCIStmtExecute (svchp, p_sql, errhp, (ub4) 1, (ub4) 0,
                (OCISnapshot *) NULL, (OCISnapshot *) NULL,
                (ub4) OCI_COMMIT_ON_SUCCESS));


  printf (" Field3 Setelah:\n");
  printf (" ukuran ---> %d\n", sizeof (field3));
  printf (" panjang ---> %d\n", strlen (field3));
  printf (" nilai ---> %s\n", field3);

  HANDLE_ERROR (errhp, OCIHandleFree (p_sql, OCI_HTYPE_STMT));
}

/* hapus tabel yang diperlukan untuk contoh ini */
void
drop_table (OCISvcCtx * svchp, OCIError * errhp, OCIEnv * envhp)
{
  OCIStmt *stmhp;
  text *statement = (text *)"DROP TABLE OCISPEC";
  ub4 status = OCI_SUCCESS;

  /*
   * Inisialisasi & Alokasikan Handle Pernyataan
   */
  HANDLE_ERROR (errhp,
        OCIHandleAlloc (envhp, (dvoid **) & stmhp,
                OCI_HTYPE_STMT, (size_t) 0, (dvoid **) 0));

  /*
   * Persiapkan pernyataan drop
   */
  HANDLE_ERROR (errhp,
        OCIStmtPrepare (stmhp, errhp,
                statement, strlen ((const char *) statement),
                OCI_NTV_SYNTAX, OCI_DEFAULT));

  /*
   * Eksekusi pernyataan drop
   */
  if ((status = OCIStmtExecute (svchp, stmhp, errhp,
                   (ub4) 1, (ub4) 0, NULL, NULL, OCI_DEFAULT)) < OCI_SUCCESS)
    {
      printf ("KEGAGALAN DALAM MENGHAPUS TABEL\n");
      HANDLE_ERROR (errhp, status);
      return;
    }
  else
    {
      printf ("********************************************\n");
      printf ("Tonggak Sejarah : Tabel berhasil dihapus\n");
      printf ("********************************************\n");
    }
  HANDLE_ERROR (errhp, OCIHandleFree (stmhp, OCI_HTYPE_STMT));
}

void
drop_stored_procs (OCISvcCtx * svchp, OCIError * errhp, OCIEnv * envhp)
{
  OCIStmt *stmhp;
  OCIStmt *stmhp2;
  OCIStmt *stmhp3;

  text *create_statement = (text *)"DROP PROCEDURE StoredProcedureSample1";
  text *create_statement2 = (text *)"DROP PROCEDURE StoredProcedureSample2";
  text *create_statement3 = (text *)"DROP FUNCTION  f1";


  ub4 status = OCI_SUCCESS;
  OCITransCommit( svchp, errhp, OCI_DEFAULT );
  /*
   * Inisialisasi & Alokasikan Handle Pernyataan
   */
  HANDLE_ERROR (errhp,
        OCIHandleAlloc (envhp, (dvoid **) & stmhp,
                OCI_HTYPE_STMT, (size_t) 0, (dvoid **) 0));
  HANDLE_ERROR (errhp,
        OCIHandleAlloc (envhp, (dvoid **) & stmhp2,
                OCI_HTYPE_STMT, (size_t) 0, (dvoid **) 0));
  HANDLE_ERROR (errhp,
        OCIHandleAlloc (envhp, (dvoid **) & stmhp3,
                OCI_HTYPE_STMT, (size_t) 0, (dvoid **) 0));

  /*
   * Persiapkan pernyataan Create
   */

  HANDLE_ERROR (errhp,
        OCIStmtPrepare (stmhp, errhp,
                create_statement,
                strlen ((const char *) create_statement),
                OCI_NTV_SYNTAX, OCI_DEFAULT));
  HANDLE_ERROR (errhp,
        OCIStmtPrepare (stmhp2, errhp, create_statement2,
                strlen ((const char *) create_statement2),
                OCI_NTV_SYNTAX, OCI_DEFAULT));
  HANDLE_ERROR (errhp,
        OCIStmtPrepare (stmhp3, errhp, create_statement3,
                strlen ((const char *) create_statement3),
                OCI_NTV_SYNTAX, OCI_DEFAULT));

  /*
   * Eksekusi Pernyataan Create SampleProcedure1
   */
  if ((status = OCIStmtExecute (svchp, stmhp, errhp,
                   (ub4) 1, (ub4) 0, NULL, NULL, OCI_DEFAULT)) < OCI_SUCCESS)
    {
      printf ("KEGAGALAN DALAM MENGHAPUS PROSEDUR 1\n");
      HANDLE_ERROR (errhp, status);
      return;
    }
  else
    {
      printf ("********************************************\n");
      printf ("Tonggak Sejarah : Contoh Prosedur 1 Berhasil dihapus\n");
      printf ("********************************************\n");
    }

  /*
   * Eksekusi Pernyataan Create Sample Procedure2
   */
  if ((status = OCIStmtExecute (svchp, stmhp2, errhp,
                   (ub4) 1, (ub4) 0, NULL, NULL, OCI_DEFAULT)) < OCI_SUCCESS)
    {
      printf ("KEGAGALAN DALAM MENGHAPUS PROSEDUR 2\n");
      HANDLE_ERROR (errhp, status);
      return;
    }
  else
    {
      printf ("********************************************\n");
      printf ("Tonggak Sejarah : Contoh Prosedur 2 Berhasil dihapus\n");
      printf ("********************************************\n");
    }

  /*
   * Eksekusi Pernyataan Create Sample Procedure3
   */
  if ((status = OCIStmtExecute (svchp, stmhp3, errhp,
                   (ub4) 1, (ub4) 0, NULL, NULL, OCI_DEFAULT)) < OCI_SUCCESS)
    {
      printf ("KEGAGALAN DALAM MENGHAPUS PROSEDUR 3\n");
      HANDLE_ERROR (errhp, status);
      return;
    }
  else
    {
      printf ("********************************************\n");
      printf ("Tonggak Sejarah : Contoh Prosedur 3 Berhasil dihapus\n");
      printf ("********************************************\n");
    }


  HANDLE_ERROR (errhp, OCIHandleFree (stmhp, OCI_HTYPE_STMT));
  HANDLE_ERROR (errhp, OCIHandleFree (stmhp2, OCI_HTYPE_STMT));
  HANDLE_ERROR (errhp, OCIHandleFree (stmhp3, OCI_HTYPE_STMT));

}

/* Bersihkan semuanya */
void
cleanup (OCISvcCtx ** svchp, OCIServer ** srvhp, OCISession ** authp,
     OCIError ** errhp, OCIEnv ** envhp)
{
  /*
   * keluar
   */
  HANDLE_ERROR (*errhp, OCISessionEnd (*svchp, *errhp, *authp, OCI_DEFAULT));
  printf ("keluar\n");

  /*
   * lepaskan dari server
   */
  HANDLE_ERROR (*errhp, OCIServerDetach (*srvhp, *errhp, OCI_DEFAULT));
  printf ("terlepas dari server\n");

  /*
   * bebaskan handle
   */
  HANDLE_ERROR (*errhp, OCIHandleFree (*authp, OCI_HTYPE_SESSION));
  /* bebaskan handle sesi */
  *authp = 0;
  HANDLE_ERROR (*errhp, OCIHandleFree (*srvhp, OCI_HTYPE_SERVER));
  /* bebaskan handle server */
  *srvhp = 0;
  HANDLE_ERROR (*errhp, OCIHandleFree (*svchp, OCI_HTYPE_SVCCTX));
  /* bebaskan konteks layanan */
  *svchp = 0;
  HANDLE_ERROR (*errhp, OCIHandleFree (*errhp, OCI_HTYPE_ERROR));
  /* bebaskan handle kesalahan */
  *errhp = 0;
  OCIHandleFree (*envhp, OCI_HTYPE_ENV);
  /* bebaskan handle lingkungan */
  *envhp = 0;
  printf ("bebas semua handle\n");
}

Dalam contoh kode sebelumnya, Anda harus mengganti parameter berikut dengan informasi koneksi tentang kluster PolarDB Anda.

Kompilasi kode

• Linux
  1. Modifikasi file Makefile untuk menautkan secara dinamis ke jalur tempat file polaroci.so berada.
     Isi berikut adalah contoh file Makefile:

     # ============================================================================
     # Copyright (c) 2004-2012 PolarDB Corporation. All Rights Reserved.
     # ===========================================================================
     
     # Makefile untuk membangun test case C untuk OCILib
     #
     
     CC=gcc
     CFLAGS=-Wall -g -I$(ORACLE_HOME)/ -L $(POLARDBOCI_LIB) -lpolaroci -lpq -liconv
     
     SAMPLES = polardb_demo
     
     all: $(SAMPLES)
     
     %:%.o
         $(CC) $(CFLAGS) -o $@
     clean:
         rm -rf $(SAMPLES)

     • Tautkan ORACLE_HOME ke direktori instantclient_12_1/sdk/include dari file header oci oracle yang diunduh dari direktori driver.
     • Tautkan POLARDBOCI_LIB ke direktori tempat file libpolaroci.so, libpq.so, dan libiconv.so berada.
  2. Jalankan perintah berikut untuk mengompilasi kode:

     make

• Windows

  Dalam topik ini, Visual Studio digunakan dalam contoh.

  1. Tambahkan jalur paket pengembangan oci oracle di direktori driver ke C/C++ > General > Attachment Include Directories.
  2. Tambahkan jalur polardboci.dll dan polardboci.lib di direktori driver ke Linker > General > Additional Library Directories.
  3. Masukkan polardboci.lib di Linker > Input > Additional Dependencies.

Contoh

Berikut adalah file yang dapat dieksekusi yang diperoleh setelah polardb_demo dikompilasi:

********************************************
Tonggak Sejarah  : Masuk sebagai --> 'parallels'
********************************************
********************************************
Tonggak Sejarah : Tabel berhasil dibuat
********************************************
********************************************
Tonggak Sejarah : Data berhasil dimasukkan 
 & Dikomit melalui Transaksi
********************************************
********************************************
Tonggak Sejarah : Contoh Prosedur 1 Berhasil dibuat
********************************************
********************************************
Tonggak Sejarah : Contoh Prosedur 2 Berhasil dibuat
********************************************
********************************************
Tonggak Sejarah : Contoh Prosedur 3 Berhasil dibuat
********************************************
name -> [SMITH]    mgr -> [7886]
hiredate -> [2007-08-02 00:00:00]
name -> [ALLEN]    mgr -> [7110]
hiredate -> [2007-04-02 00:00:00]
name -> [KING]    mgr -> [7221]
hiredate -> [2007-03-02 00:00:00]
*************************************************
Contoh 1 - Menggunakan Parameter IN OUT
*************************************************
 Field2 Sebelum:
 ukuran ---> 20
 panjang ---> 7
 nilai ---> Entry 3
 Field2 Setelah:
 ukuran ---> 20
 panjang ---> 10
 nilai ---> Successful
*************************************************
Contoh 2 - Menggunakan Parameter OUT
*************************************************
 Field3 Sebelum:
 ukuran ---> 20
 panjang ---> 0
 nilai ---> 
 Field3 Setelah:
 ukuran ---> 20
 panjang ---> 10
 nilai ---> Successful
********************************************
Tonggak Sejarah : Tabel berhasil dihapus
********************************************
********************************************
Tonggak Sejarah : Contoh Prosedur 1 Berhasil dihapus
********************************************
********************************************
Tonggak Sejarah : Contoh Prosedur 2 Berhasil dihapus
********************************************
********************************************
Tonggak Sejarah : Contoh Prosedur 3 Berhasil dihapus
********************************************
keluar
terlepas dari server
bebas semua handle