/*
 * Oracle support for dbMetrix Database Tool v0.1
 * Copyright (c) 1998 David E. Storey <dave@tamos.net>
 * Copyright (c) 1998 Stace A. Zacharov <stace@commed.ru>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */

#include <gtk/gtk.h>

#include <stdio.h>
#include <ctype.h>
#include <string.h>


/* Include OCI-specific headers. */
#include <oratypes.h>
#include <ocidfn.h>
#ifdef __STDC__
#include <ociapr.h>
#else
#include <ocikpr.h>
#endif
/*#include <ocidem.h>*/

#include "config.h"
#include "global.h"

/****************************
 * Oracle defines
 ****************************/

/*  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 OBJECT_NOT_EXIST       942
#define VAR_NOT_IN_LIST       1007
#define NO_DATA_FOUND         1403
#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

/*
** Size of HDA area:
** 512 for 64 bit arquitectures
** 256 for 32 bit arquitectures
*/

#if (defined(__osf__) && defined(__alpha)) || defined(CRAY) || defined(KSR) || defined(SS_64BIT_SERVER)
# define HDA_SIZE 512
#else
# define HDA_SIZE 256
#endif

/****************************
 * Local defines
 ****************************/

/* Constants used in this program. */
#define MAX_SELECT_LIST_SIZE    33
#define MAX_ITEM_BUFFER_SIZE    2000
#define MSG_BUFFER_SIZE         512

/* Font properties */
#define FONT_SIZE               8
#define BUTTON_ADD_SIZE         5
#define WINDOW_ADD_SIZE         50

/* Declare structures for query information. */
struct desc_Oracle
{
    sb4             dbsize;
    sb2             dbtype;
    sb1             buf[MAX_ITEM_BUFFER_SIZE];
    sb4             buflen;
    sb4             dsize;
    sb2             precision;
    sb2             scale;
    sb2             nullok;
};

struct def_Oracle
{
    ub1             buf[MAX_ITEM_BUFFER_SIZE];
    float           flt_buf;
    sword           int_buf;
    sb2             indp;
    ub2             col_retlen, col_retcode;
};

/* Buffer for messages */
text msg[MSG_BUFFER_SIZE];

#define DBX_ORACLE(conn)  (dbx_Oracle *)conn

typedef enum {
    DBX_ORACLE_COMMIT,
    DBX_ORACLE_ROLLBACK
} dbx_Oracle_enums;

#define PARSE_NO_DEFER           0
#define PARSE_V7_LNG             2

typedef struct {
    /* Define one logon data area and one cursor data area
     Also define a host data area for olog.
     (See ocidfn.h for declarations). */
    Lda_Def lda;
    ub4     hda[HDA_SIZE/(sizeof(ub4))];
    char *host;
    char *user;
    char *pass;
} dbx_Oracle;

/* prototypes */
void close_Oracle(dataSource *dbconn);
void create_Oracle_addDialog(GtkWidget *dWindow, GtkWidget *notebook, int *curpage);
void create_Oracle_dsEntry(GtkWidget *widget);
void init_Oracle(void);
void query_Oracle(dataSource *dbconn, char *query);
void refresh_Oracle(GtkWidget *treeItem, gpointer data);
GtkWidget *result_Oracle(Lda_Def *lda, Cda_Def *cda);
void misc_Oracle(GtkWidget *widget, gpointer data);
void props_host_Oracle(GtkWidget *widget, gpointer data);

void
close_Oracle(dataSource *dbconn)
{
    dbx_Oracle *conn = DBX_ORACLE(dbconn->info);
    ologof(&conn->lda);
    g_free(conn->host);
    g_free(conn->user);
    g_free(conn->pass);
    g_free(conn);
}

void
create_Oracle_addDialog(GtkWidget *dWindow, GtkWidget *notebook, int *curpage)
{
    dbx_Dialog entries[] = {
        {"Username:", "Oracle_User", FALSE},
        {"Password:", "Oracle_Pass", TRUE},
        {"Server:", "Oracle_Serv", FALSE},
    };

    create_dialogs(dWindow, notebook, curpage, Oracle, "Oracle", entries, sizeof(entries)/sizeof(entries[0]));
}

void
create_Oracle_dsEntry(GtkWidget *widget)
{
    dbx_Oracle *dbconn;
    char *host, *user, *pass;
    char name[256];

    host = get_entry_text(widget, "Oracle_Serv", FALSE);
    user = get_entry_text(widget, "Oracle_User", FALSE);
    pass = get_entry_text(widget, "Oracle_Pass", TRUE);

    g_snprintf(name, 256, "oracle://%s@%s", user, host);

    /* check for another entry in the same tree */
    if (fetch_ds_key(name))
        return;

    /* connect to server */
    /* Memory for LDA and HDA need to be cleared before use */
    dbconn = DBX_ORACLE(calloc(1,sizeof(dbx_Oracle)));
    if( dbconn == NULL){
        s_print("ERROR: Can't get memory for login data");
        return;
    }

    if ( ! olog(&dbconn->lda, (ub1 *)&dbconn->hda,
                (text*)user, -1, (text*)pass, -1,
                (text*)host, -1, (ub4)OCI_LM_DEF)){
        dbconn->host = g_strdup(host);
        dbconn->user = g_strdup(user);
        dbconn->pass = g_strdup(pass);
        ds_add(name, dbconn, Oracle, Host);
    } else {
        oerhms(&dbconn->lda, dbconn->lda.rc, msg, (sword) sizeof (msg));
        s_print((char *)msg);
        g_free(dbconn);
    }
}

void
query_Oracle(dataSource *conn, char *query)
{
    dbx_Oracle *dbconn;
    Cda_Def *cda;
    sword sql_function;

    if (conn && query)
        dbconn = DBX_ORACLE(conn->info);
    else
        return;

    /* Memory for CDA also need to be cleared before use */
    cda = (Cda_Def*)calloc(1,sizeof(Cda_Def));
    if( cda == NULL){
        s_print("ERROR: Can't get memory for cursor data");
        return;
    }

    /* Open a cursor */
    if (oopen(cda, &dbconn->lda, (text *) 0, -1, -1, (text *) 0, -1))
    {
        oerhms(&dbconn->lda, cda->rc, msg, (sword) sizeof (msg));
        s_print((char *)msg);
        g_free(cda);
        return;
    }

    /* Parse Statement */
    if (oparse(cda, (text *)query,
               (sb4) -1, (sword) PARSE_NO_DEFER, (ub4) PARSE_V7_LNG))
    {
        oerhms(&dbconn->lda, cda->rc, msg, (sword) sizeof (msg));
        s_print((char *)msg);
        oclose(cda);
        g_free(cda);
        return;
    }
    /* Execute the statement. */
    if (oexec(cda))
    {
        oerhms(&dbconn->lda, cda->rc, msg, (sword) sizeof (msg));
        s_print((char *)msg);
        oclose(cda);
        g_free(cda);
        return;
    }

    /* Save the SQL function code right after parse. */
    sql_function = cda->ft;

    /* If this is query - show query window */
    if (sql_function == FT_SELECT){
        query_window(result_Oracle(&dbconn->lda, cda));
    }
    /* Print the rows-processed count. */
    if (sql_function == FT_SELECT ||
        sql_function == FT_UPDATE ||
        sql_function == FT_DELETE ||
        sql_function == FT_INSERT){
        g_snprintf((char *)msg, MSG_BUFFER_SIZE,
                   "%ld row%c processed.", cda->rpc,
                   cda->rpc == 1 ? ' ' : 's');
        s_print((char *)msg);
    }else{
        s_print("Statement processed.");
    }

    oclose(cda);
    g_free(cda);
    return;
}

GtkWidget *
result_Oracle(Lda_Def *lda, Cda_Def *cda)
{
    GtkWidget *clist;
    struct desc_Oracle *desc;
    struct def_Oracle *def;
    sword col, deflen, deftyp;
    static ub1 *defptr;
    unsigned *maxflengths;
    int i, total, numrows;
    char strbuf[MAX_ITEM_BUFFER_SIZE];
    char *strarr[MAX_SELECT_LIST_SIZE];

    /* Memory for describe buffer */
    desc = calloc(MAX_SELECT_LIST_SIZE,sizeof(struct desc_Oracle));
    if( desc == NULL){
        s_print("ERROR: Can't get memory for describe Buffer");
        return(NULL);
    }

    /* Memory for define buffer */
    def = calloc(MAX_SELECT_LIST_SIZE,sizeof(struct def_Oracle));
    if( def == NULL){
        s_print("ERROR: Can't get memory for describe Buffer");
        return(NULL);
    }

    /* Describe the select-list items. */
    for (col = 0; col < MAX_SELECT_LIST_SIZE; col++)
    {
        desc[col].buflen = MAX_ITEM_BUFFER_SIZE;
        if (odescr(cda, col + 1, &desc[col].dbsize,
                   &desc[col].dbtype, &desc[col].buf[0],
                   &desc[col].buflen, &desc[col].dsize,
                   &desc[col].precision, &desc[col].scale,
                   &desc[col].nullok))
        {
            /* Break on end of select list. */
            if (cda->rc == VAR_NOT_IN_LIST)
                break;
            else
            {
                oerhms(lda, cda->rc, msg, (sword) sizeof (msg));
                s_print((char *)msg);
                return(NULL);
            }
        }
        /* adjust sizes and types for display */
        switch (desc[col].dbtype)
        {
        case NUMBER_TYPE:
            desc[col].dbsize = 8;
            /* Handle NUMBER with scale as float. */
            if (desc[col].scale != 0)
            {
                defptr = (ub1 *) &def[col].flt_buf;
                deflen = (sword) sizeof(float);
                deftyp = FLOAT_TYPE;
                desc[col].dbtype = FLOAT_TYPE;
            }
            else
            {
                defptr = (ub1 *) &def[col].int_buf;
                deflen = (sword) sizeof(sword);
                deftyp = INT_TYPE;
                desc[col].dbtype = INT_TYPE;
            }
            break;
        default:
            if (desc[col].dbtype == DATE_TYPE)
                desc[col].dbsize = 9;
            if (desc[col].dbtype == ROWID_TYPE)
                desc[col].dbsize = 18;
            defptr = def[col].buf;
            deflen = desc[col].dbsize > MAX_ITEM_BUFFER_SIZE ?
              MAX_ITEM_BUFFER_SIZE : desc[col].dbsize + 1;
            deftyp = STRING_TYPE;
            break;
        }
        if (odefin(cda, col + 1,
                   defptr, deflen, deftyp,
                   -1, &def[col].indp, (text *) 0, -1, -1,
                   &def[col].col_retlen,
                   &def[col].col_retcode))
        {
            oerhms(lda, cda->rc, msg, (sword) sizeof (msg));
            s_print((char *)msg);
            return(NULL);
        }
    }

    maxflengths = (unsigned *)calloc(col, sizeof(unsigned));
    if( maxflengths == NULL){
        s_print("ERROR: Can't get memory for array of field lengths");
        return(NULL);
    }
    
    clist = gtk_clist_new(col);

    for (i = 0; i < col; i++)
    {
        desc[i].buf[desc[i].buflen]=0;
        maxflengths[i] = desc[i].buflen;
        gtk_clist_set_column_title(GTK_CLIST(clist), i, (char *)desc[i].buf);
    }

    for(numrows = 0;; numrows++){
        if( ofetch(cda) != 0){
            if( cda->rc == NO_DATA_FOUND){
                break;
            }else{
                oerhms(lda, cda->rc, msg, (sword) sizeof (msg));
                s_print((char *)msg);
                break;
            }
        }

        for(i = 0; i < col; i++){
            if (def[i].indp < 0){
                /*strcpy( strbuf, "NULL");*/
                strbuf[0]=0;
            }else{
                switch (desc[i].dbtype)
                {
                case FLOAT_TYPE:
                    g_snprintf( strbuf, MAX_ITEM_BUFFER_SIZE,
                                "%8.2f", def[i].flt_buf);
                    break;
                case INT_TYPE:
                    g_snprintf( strbuf, MAX_ITEM_BUFFER_SIZE,
                                "%8d", def[i].int_buf);
                    break;
                default:
                    g_snprintf( strbuf, MAX_ITEM_BUFFER_SIZE,
                                "%s", def[i].buf);
                    break;
                }
            }
            if (strlen(strbuf) > maxflengths[i])
                maxflengths[i] = strlen(strbuf);
            strarr[i]=g_strdup(strbuf);
        }
        gtk_clist_append(GTK_CLIST(clist), strarr);
        for(i = 0; i < col; i++)
            free(strarr[i]);
    }
    
    total=0;
    for (i = 0; i < col; i++)
    {
        total += (maxflengths[i] * FONT_SIZE) + BUTTON_ADD_SIZE;
        gtk_clist_set_column_width(GTK_CLIST(clist), i,
                                   (maxflengths[i] * FONT_SIZE)
                                   + BUTTON_ADD_SIZE);
    }
    total+=WINDOW_ADD_SIZE;
    gtk_object_set_data(GTK_OBJECT(clist), "width", (gpointer)total);
    gtk_object_set_data(GTK_OBJECT(clist), "height", (gpointer)col);
    free(maxflengths);

    return(clist);
}

void
refresh_Oracle(GtkWidget *treeItem, gpointer data)
{
    node_ds *nodeInfo = (node_ds *)data;
    dbx_Oracle *dbconn = DBX_ORACLE(nodeInfo->conn->info);
    Cda_Def *cda;
    text buff[32];
    sb2 indp;
    int i;

    /* Memory for CDA also need to be cleared before use */
    cda = (Cda_Def*)calloc(1,sizeof(Cda_Def));
    if( cda == NULL){
        s_print("ERROR: Can't get memory for cursor data");
        return;
    }

    /* Open a cursor */
    if (oopen(cda, &dbconn->lda, (text *) 0, -1, -1, (text *) 0, -1))
    {
        oerhms(&dbconn->lda, cda->rc, msg, (sword) sizeof (msg));
        s_print((char *)msg);
        g_free(cda);
        return;
    }

    
    switch(nodeInfo->type)
    {
    case Host:
        /* Get List of all users */
        /* Parse Statement */
        if (oparse(cda, (text *)"SELECT username from ALL_USERS",
                   (sb4) -1, (sword) PARSE_NO_DEFER, (ub4) PARSE_V7_LNG))
        {
            oerhms(&dbconn->lda, cda->rc, msg, (sword) sizeof (msg));
            s_print((char *)msg);
            oclose(cda);
            g_free(cda);
            return;
        }
        /* Execute the statement. */
        if (oexec(cda))
        {
            oerhms(&dbconn->lda, cda->rc, msg, (sword) sizeof (msg));
            s_print((char *)msg);
            oclose(cda);
            g_free(cda);
            return;
        }
        break;
    case Database:
        /* List of shema objects*/
        /* Parse Statement */
        if (oparse(cda, (text *)"SELECT object_name from ALL_OBJECTS"
                   " WHERE object_type IN ('TABLE','VIEW')"
                   " AND owner=:owner",
                   (sb4) -1, (sword) PARSE_NO_DEFER, (ub4) PARSE_V7_LNG))
        {
            oerhms(&dbconn->lda, cda->rc, msg, (sword) sizeof (msg));
            s_print((char *)msg);
            oclose(cda);
            g_free(cda);
            return;
        }
        if( obndrv(cda, (text *) ":owner", -1, (ub1 *) nodeInfo->name,
                   -1, VARCHAR2_TYPE, -1, (sb2 *) 0, (text *) 0, -1, -1))
        {
            oerhms(&dbconn->lda, cda->rc, msg, (sword) sizeof (msg));
            s_print((char *)msg);
            oclose(cda);
            g_free(cda);
            return;
        }
                   
        /* Execute the statement. */
        if (oexec(cda))
        {
            oerhms(&dbconn->lda, cda->rc, msg, (sword) sizeof (msg));
            s_print((char *)msg);
            oclose(cda);
            g_free(cda);
            return;
        }
        break;
    case Table:
        /* List of objects properties*/
        /* Parse Statement */
        if (oparse(cda, (text *)"SELECT column_name from ALL_TAB_COLUMNS"
                   " WHERE owner=:owner AND table_name=:tablename",
                   (sb4) -1, (sword) PARSE_NO_DEFER, (ub4) PARSE_V7_LNG))
        {
            oerhms(&dbconn->lda, cda->rc, msg, (sword) sizeof (msg));
            s_print((char *)msg);
            oclose(cda);
            g_free(cda);
            return;
        }
        if( obndrv(cda, (text *) ":tablename", -1, (ub1 *) nodeInfo->name,
                   -1, VARCHAR2_TYPE, -1, (sb2 *) 0, (text *) 0, -1, -1))
        {
            oerhms(&dbconn->lda, cda->rc, msg, (sword) sizeof (msg));
            s_print((char *)msg);
            oclose(cda);
            g_free(cda);
            return;
        }
        if( obndrv(cda, (text *) ":owner", -1,
                   (ub1 *) nodeInfo->parent->name, -1, VARCHAR2_TYPE,
                   -1, (sb2 *) 0, (text *) 0, -1, -1))
        {
            oerhms(&dbconn->lda, cda->rc, msg, (sword) sizeof (msg));
            s_print((char *)msg);
            oclose(cda);
            g_free(cda);
            return;
        }
                   
        /* Execute the statement. */
        if (oexec(cda))
        {
            oerhms(&dbconn->lda, cda->rc, msg, (sword) sizeof (msg));
            s_print((char *)msg);
            oclose(cda);
            g_free(cda);
            return;
        }
        break;
    case Field:
        oclose(cda);
        g_free(cda);
        return;
        break;
    }

    indp=0;
    if (odefin(cda, 1, (ub1 *)buff, (sword)30, (sword)STRING_TYPE,
               (sword) -1, &indp, (text *)0, -1, -1, (ub2 *)0, (ub2 *)0))
    {
        oerhms(&dbconn->lda, cda->rc, msg, (sword) sizeof (msg));
        s_print((char *)msg);
        oclose(cda);
        g_free(cda);
        return;
    }

    i=0;
    while(1){
        if( ofetch(cda) != 0){
            if( cda->rc == NO_DATA_FOUND){
                break;
            }else{
                oerhms(&dbconn->lda, cda->rc, msg, (sword) sizeof (msg));
                s_print((char *)msg);
                break;
            }
        }
        if( indp == 0){
            if (!GTK_TREE_ITEM_SUBTREE(treeItem))
                add_subtree(treeItem);
            tree_refresh(treeItem, nodeInfo, i, (char *)buff);
            i++;
        }
    }
    oclose(cda);
    g_free(cda);
    return;
}

void
misc_Oracle(GtkWidget *widget, gpointer data)
{
    GtkWidget *treeItem = (GtkWidget *)
        gtk_object_get_data(GTK_OBJECT(dbTree), "selected");
    node_ds *nodeInfo = (node_ds *)
        gtk_object_get_data(GTK_OBJECT(treeItem), "info");
    dbx_Oracle *dbconn = DBX_ORACLE(nodeInfo->conn->info);
    Cda_Def *cda;

    /* Memory for CDA also need to be cleared before use */
    cda = (Cda_Def*)calloc(1,sizeof(Cda_Def));
    if( cda == NULL){
        s_print("ERROR: Can't get memory for cursor data");
        return;
    }

    /* Open a cursor */
    if (oopen(cda, &dbconn->lda, (text *) 0, -1, -1, (text *) 0, -1))
    {
        oerhms(&dbconn->lda, cda->rc, msg, (sword) sizeof (msg));
        s_print((char *)msg);
        g_free(cda);
        return;
    }

    switch((int)data)
    {
    case DBX_ORACLE_COMMIT:
        /* Parse Statement */
        if (oparse(cda, (text *)"COMMIT",
                   (sb4) -1, (sword) PARSE_NO_DEFER, (ub4) PARSE_V7_LNG))
        {
            oerhms(&dbconn->lda, cda->rc, msg, (sword) sizeof (msg));
            s_print((char *)msg);
            oclose(cda);
            g_free(cda);
            return;
        }
        /* Execute the statement. */
        if (oexec(cda))
        {
            oerhms(&dbconn->lda, cda->rc, msg, (sword) sizeof (msg));
            s_print((char *)msg);
            oclose(cda);
            g_free(cda);
            return;
        }
        s_print( "COMMIT completed.");
        break;
    case DBX_ORACLE_ROLLBACK:
        /* Parse Statement */
        if (oparse(cda, (text *)"ROLLBACK",
                   (sb4) -1, (sword) PARSE_NO_DEFER, (ub4) PARSE_V7_LNG))
        {
            oerhms(&dbconn->lda, cda->rc, msg, (sword) sizeof (msg));
            s_print((char *)msg);
            oclose(cda);
            g_free(cda);
            return;
        }
        /* Execute the statement. */
        if (oexec(cda))
        {
            oerhms(&dbconn->lda, cda->rc, msg, (sword) sizeof (msg));
            s_print((char *)msg);
            oclose(cda);
            g_free(cda);
            return;
        }
        s_print( "ROLLBACK completed.");
        break;
    default:
        s_print( "Internal error: Unknown command called");
        break;
    }
    oclose(cda);
    g_free(cda);
    return;
}

void
props_host_Oracle(GtkWidget *widget, gpointer data)
{
    GtkWidget *frame;
    GtkWidget *tLayout;
    GtkWidget *label;
    GtkWidget *notebook;
    GtkWidget *clist;

    GtkWidget *treeItem = (GtkWidget *)
        gtk_object_get_data(GTK_OBJECT(dbTree), "selected");
    node_ds *nodeInfo = (node_ds *)
        gtk_object_get_data(GTK_OBJECT(treeItem), "info");
    dbx_Oracle *dbconn = DBX_ORACLE(nodeInfo->conn->info);

    int IS_DBA;
    Cda_Def *cda;
    text buff[100];
    sb2 indp;
    int i;

    /* Memory for CDA also need to be cleared before use */
    cda = (Cda_Def*)calloc(1,sizeof(Cda_Def));
    if( cda == NULL){
        s_print("ERROR: Can't get memory for cursor data");
        return;
    }

    frame = new_dialog("Oracle Properties", "Oracle Server Properties");

    /* create notebook */
    notebook = gtk_notebook_new();
    gtk_notebook_set_show_tabs(GTK_NOTEBOOK(notebook), TRUE);
    gtk_container_add(GTK_CONTAINER(frame), notebook);
    gtk_widget_show(notebook);

    tLayout = gtk_table_new(10, 1, FALSE);
    gtk_table_set_row_spacings(GTK_TABLE(tLayout), 1);
    gtk_table_set_col_spacings(GTK_TABLE(tLayout), 3);
    gtk_container_border_width(GTK_CONTAINER(tLayout), 4);

    /* create information tab */
    label = gtk_label_new("Information");
    gtk_notebook_append_page(GTK_NOTEBOOK(notebook), tLayout, label);
    gtk_widget_show(tLayout);

    /* Open a cursor */
    if (oopen(cda, &dbconn->lda, (text *) 0, -1, -1, (text *) 0, -1))
    {
        oerhms(&dbconn->lda, cda->rc, msg, (sword) sizeof (msg));
        s_print((char *)msg);
        g_free(cda);
        return;
    }

    /* Parse Statement */
    if (oparse(cda, (text *)"SELECT banner FROM v$version",
               (sb4) -1, (sword) PARSE_NO_DEFER, (ub4) PARSE_V7_LNG))
    {
        oerhms(&dbconn->lda, cda->rc, msg, (sword) sizeof (msg));
        s_print((char *)msg);
        oclose(cda);
        g_free(cda);
        return;
    }

    /* Execute the statement. */
    if (oexec(cda))
    {
        oerhms(&dbconn->lda, cda->rc, msg, (sword) sizeof (msg));
        s_print((char *)msg);
        oclose(cda);
        g_free(cda);
        return;
    }

    /* Bind output variable*/
    indp=0;
    if (odefin(cda, 1, (ub1 *)buff, (sword)99, (sword)STRING_TYPE,
               (sword) -1, &indp, (text *)0, -1, -1, (ub2 *)0, (ub2 *)0))
    {
        oerhms(&dbconn->lda, cda->rc, msg, (sword) sizeof (msg));
        s_print((char *)msg);
        oclose(cda);
        g_free(cda);
        return;
    }

    i=1;
    while(1){
        if( ofetch(cda) != 0){
            if( cda->rc == NO_DATA_FOUND){
                break;
            }else{
                oerhms(&dbconn->lda, cda->rc, msg, (sword) sizeof (msg));
                s_print((char *)msg);
                break;
            }
        }
        if( indp == 0){
            label = gtk_label_new((char *)buff);
            gtk_misc_set_alignment(GTK_MISC(label), 0.5, 0.5);
            gtk_table_attach(GTK_TABLE(tLayout), label, 0, 1, i, i+1,
                             GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
            gtk_widget_show(label);
            i++;
        }
    }
    oclose(cda);

    /* create parameters tab */

    /* Open a cursor */
    if (oopen(cda, &dbconn->lda, (text *) 0, -1, -1, (text *) 0, -1))
    {
        oerhms(&dbconn->lda, cda->rc, msg, (sword) sizeof (msg));
        s_print((char *)msg);
        g_free(cda);
        return;
    }

    /* Parse Statement */
    if (oparse(cda, (text *)"SELECT name \"Parameter Name\","
               " DECODE( isdefault, 'TRUE', 'Yes', 'FALSE', 'No')"
               " \"Default\","
               " DECODE( type, 1, 'Boolean', 2, 'String', 3, 'Integer')"
               " \"Type\","
               " value \"Value\""
               " FROM v$parameter"
               " ORDER BY 1",
               (sb4) -1, (sword) PARSE_NO_DEFER, (ub4) PARSE_V7_LNG))
    {
        if( cda->rc == OBJECT_NOT_EXIST){
            IS_DBA=0;
        }else{
            oerhms(&dbconn->lda, cda->rc, msg, (sword) sizeof (msg));
            s_print((char *)msg);
            oclose(cda);
            g_free(cda);
            return;
        }
    }else{
        IS_DBA=1;

        /* Execute the statement. */
        if (oexec(cda))
        {
            oerhms(&dbconn->lda, cda->rc, msg, (sword) sizeof (msg));
            s_print((char *)msg);
            oclose(cda);
            g_free(cda);
            return;
        }

        clist = result_Oracle(&dbconn->lda, cda);
        gtk_widget_show(clist);
        gtk_clist_column_titles_passive(GTK_CLIST(clist));
        gtk_clist_column_titles_show(GTK_CLIST(clist));
        gtk_clist_set_selection_mode(GTK_CLIST(clist), GTK_SELECTION_SINGLE);
        label = gtk_label_new("Parameters");
        gtk_notebook_append_page(GTK_NOTEBOOK(notebook), clist, label);
    }
    oclose(cda);

    /* Create other tabs, if DBA only */
    if( IS_DBA){
        
        /* Create Database tab */
        
        /* Open a cursor */
        if (oopen(cda, &dbconn->lda, (text *) 0, -1, -1, (text *) 0, -1))
        {
            oerhms(&dbconn->lda, cda->rc, msg, (sword) sizeof (msg));
            s_print((char *)msg);
            g_free(cda);
            return;
        }
        
        /* Parse Statement */
        if (oparse(cda, (text *)"SELECT name \"SGA Component\","
                   " ROUND(value/1024) \"Size (K)\""
                   " FROM v$sga"
                   " ORDER BY 1",
                   (sb4) -1, (sword) PARSE_NO_DEFER, (ub4) PARSE_V7_LNG))
        {
            oerhms(&dbconn->lda, cda->rc, msg, (sword) sizeof (msg));
            s_print((char *)msg);
            oclose(cda);
            g_free(cda);
            return;
        }

        /* Execute the statement. */
        if (oexec(cda))
        {
            oerhms(&dbconn->lda, cda->rc, msg, (sword) sizeof (msg));
            s_print((char *)msg);
            oclose(cda);
            g_free(cda);
            return;
        }

        clist = result_Oracle(&dbconn->lda, cda);
        oclose(cda);
        
        gtk_widget_show(clist);
        gtk_clist_column_titles_passive(GTK_CLIST(clist));
        gtk_clist_column_titles_show(GTK_CLIST(clist));
        gtk_clist_set_selection_mode(GTK_CLIST(clist), GTK_SELECTION_SINGLE);
        label = gtk_label_new("Database");
        gtk_notebook_append_page(GTK_NOTEBOOK(notebook), clist, label);

        /* Create Database tab */
        
        /* Open a cursor */
        if (oopen(cda, &dbconn->lda, (text *) 0, -1, -1, (text *) 0, -1))
        {
            oerhms(&dbconn->lda, cda->rc, msg, (sword) sizeof (msg));
            s_print((char *)msg);
            g_free(cda);
            return;
        }
        
        /* Parse Statement */
        if (oparse(cda, (text *)"SELECT sid \"SID\","
                   " serial# \"Serial #\", username \"Username\","
                   " schemaname \"Schema Name\", osuser \"OS User\","
                   " terminal \"Terminal\", machine \"Machine\""
                   " FROM v$session"
                   " WHERE type <> 'BACKGROUND'"
                   " ORDER BY 1",
                   (sb4) -1, (sword) PARSE_NO_DEFER, (ub4) PARSE_V7_LNG))
        {
            oerhms(&dbconn->lda, cda->rc, msg, (sword) sizeof (msg));
            s_print((char *)msg);
            oclose(cda);
            g_free(cda);
            return;
        }

        /* Execute the statement. */
        if (oexec(cda))
        {
            oerhms(&dbconn->lda, cda->rc, msg, (sword) sizeof (msg));
            s_print((char *)msg);
            oclose(cda);
            g_free(cda);
            return;
        }

        clist = result_Oracle(&dbconn->lda, cda);
        oclose(cda);
        
        gtk_widget_show(clist);
        gtk_clist_column_titles_passive(GTK_CLIST(clist));
        gtk_clist_column_titles_show(GTK_CLIST(clist));
        gtk_clist_set_selection_mode(GTK_CLIST(clist), GTK_SELECTION_SINGLE);
        label = gtk_label_new("Sessions");
        gtk_notebook_append_page(GTK_NOTEBOOK(notebook), clist, label);
    }
    
    g_free(cda);
    return;
}

void
init_Oracle(void)
{
    dbxMenuEntry oracleMenuDB[] = {
        {"properties...", NULL, DBX_SIGNAL_FUNC(props_host_Oracle), NULL},
        {NULL, NULL, NULL, NULL},
        {"commit", NULL, DBX_SIGNAL_FUNC(misc_Oracle),
        (gpointer)DBX_ORACLE_COMMIT},
        {"rollback", NULL, DBX_SIGNAL_FUNC(misc_Oracle),
        (gpointer)DBX_ORACLE_ROLLBACK},
        {NULL, NULL, NULL, NULL},
        {"disconnect", NULL, DBX_SIGNAL_FUNC(ds_close),
        (gpointer)TRUE}
    };

    dsMenus[Oracle].host = set_menu(oracleMenuDB, sizeof(oracleMenuDB)/sizeof(oracleMenuDB[0]));

    dsFuncs[Oracle].close = close_Oracle;
    dsFuncs[Oracle].create_dsEntry = create_Oracle_dsEntry;
    dsFuncs[Oracle].create_dsDialog = create_Oracle_addDialog;
    dsFuncs[Oracle].exec_query = query_Oracle;
    dsFuncs[Oracle].refresh = refresh_Oracle;
}