/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 *      db_scheme.cc
 *
 *      Copyright (c) 1988-2000 Sun Microsystems, Inc.
 *      All Rights Reserved.
 */

#include <string.h>
#include "db_headers.h"
#include "db_scheme.h"

#include "nisdb_mt.h"

/*
 *  Constructor:  create new scheme by making copy of 'orig'.
 * All items within old scheme are also copied (i.e. no shared pointers).
*/
db_scheme::db_scheme(db_scheme* orig)
{
        int numkeys, i;
        keys.keys_len = 0;
        keys.keys_val = NULL;

        if (orig == NULL) {
                WARNING("db_scheme::db_scheme: null original db_scheme");
                return;
        }

        READLOCKV(orig, "r orig db_scheme::db_scheme");

        numkeys = this->keys.keys_len = orig->keys.keys_len;
        db_key_desc * descols = this->keys.keys_val = new db_key_desc[numkeys];
        db_key_desc * srccols = orig->keys.keys_val;

        if (descols == NULL) {
                clear_columns(0);
                READUNLOCKV(orig, "ru orig db_scheme::db_scheme");
                FATAL("db_scheme::db_scheme: cannot allocate space for columns",
                DB_MEMORY_LIMIT);
        }

        for (i = 0; i < numkeys; i++) {
                if (srccols[i].key_name == NULL) {
                        clear_columns(i);
                        WARNING("db_scheme::db_scheme: null column name");
                        READUNLOCKV(orig, "ru orig db_scheme::db_scheme");
                        return;
                }
                descols[i].key_name = new item(srccols[i].key_name);
                if (descols[i].key_name == NULL) {
                        clear_columns(i);
                        READUNLOCKV(orig, "ru orig db_scheme::db_scheme");
                        FATAL(
                "db_scheme::db_scheme: cannot allocate space for column names",
                DB_MEMORY_LIMIT);
                }
                descols[i].key_flags = srccols[i].key_flags;
                descols[i].where = srccols[i].where;
                descols[i].store_type = srccols[i].store_type;
                descols[i].column_number = srccols[i].column_number;
        }
        this->max_columns = orig->max_columns;
        this->data = orig->data;
        READUNLOCKV(orig, "ru orig db_scheme::db_scheme");
        INITRW(scheme);
}

/* Constructor:  create new sheme by using information in 'zdesc'. */
db_scheme::db_scheme(table_obj *zdesc)
{
        keys.keys_len = 0;
        keys.keys_val = NULL;

        if (zdesc == NULL) {
                WARNING("db_scheme::db_scheme: null table obj");
                return;
        }

        max_columns = zdesc->ta_maxcol;

        /* find out how many searchable columns */
        int total_cols = zdesc->ta_cols.ta_cols_len;
        table_col * zcols = zdesc->ta_cols.ta_cols_val;
        int count = 0, i;

        if (zcols == NULL) {
                WARNING("db_scheme::db_scheme: no columns in nis table obj");
                return;
        }

        /* find out number of indices  */
        for (i = 0; i < total_cols; i++) {
                if (zcols[i].tc_flags&TA_SEARCHABLE)
                        ++count;
        }
        if (count == 0) {
                WARNING(
                "db_scheme::db_scheme: no searchable columns in nis table obj");
                return;
        }

        keys.keys_len = count;
        db_key_desc * scols = keys.keys_val = new db_key_desc[count];
        if (scols == NULL) {
                clear_columns(0);
                FATAL("db_scheme::db_scheme: cannot allocate space for keys",
                        DB_MEMORY_LIMIT);
        }
        int keynum = 0;

        for (i = 0; i < total_cols; i++) {
                if (zcols[i].tc_flags&TA_SEARCHABLE) {
                        if (zcols[i].tc_name == NULL) {
                                clear_columns(keynum);
                                WARNING(
            "db_scheme::db_scheme: searchable column cannot have null name");
                                return;
                        }
                        scols[keynum].key_name = new item(zcols[i].tc_name,
                                        strlen(zcols[i].tc_name));
                        if (scols[keynum].key_name == NULL) {
                                clear_columns(keynum);
                                FATAL(
                    "db_scheme::db_scheme: cannot allocate space for key names",
                    DB_MEMORY_LIMIT);
                        }
                        scols[keynum].key_flags = zcols[i].tc_flags;
                        scols[keynum].column_number = i;
                        scols[keynum].where.max_len = NIS_MAXATTRVAL;
                        scols[keynum].where.start_column = 0;
                        /* don't care about position information for now */
                        ++keynum;       /* advance to next key number */
                }
        }
        if (keynum != count) {          /* something is wrong */
                clear_columns(keynum);
                WARNING(
            "db_scheme::db_scheme: incorrect number of  searchable columns");
        }
        INITRW(scheme);
}

void
db_scheme::clear_columns(int numkeys)
{
                int j;

                WRITELOCKV(this, "w db_scheme::clear_columns");

                db_key_desc * cols = keys.keys_val;

                if (cols) {
                        for (j = 0; j < numkeys; j++) {
                                if (cols[j].key_name)
                                        delete cols[j].key_name;
                        }
                        delete cols;
                        keys.keys_val = NULL;
                }
                keys.keys_len = 0;

                WRITEUNLOCKV(this, "wu db_scheme::clear_columns");
}

/* Destructor:  delete all keys associated with scheme and scheme itself. */
db_scheme::~db_scheme()
{
        WRITELOCKV(this, "w db_scheme::~db_scheme");
        clear_columns(keys.keys_len);
        DESTROYRW(scheme);
}

/*
 * Predicate:  return whether given string is one of the index names
 * this scheme.  If so, return in 'result' the index's number.
*/
bool_t
db_scheme::find_index(char *purportedname, int *result)
{
        if (purportedname) {
                int i;
                int plen;
                plen = strlen(purportedname);

                READLOCK(this, FALSE, "r db_scheme::find_index");
                for (i = 0; i < keys.keys_len; i++) {
                        if (keys.keys_val[i].key_name->equal(purportedname,
                                                                plen, TRUE)) {
                                if (result) *result = i;
                                READUNLOCK(this, TRUE,
                                        "ru db_scheme::find_index");
                                return (TRUE);
                        }
                }
                READUNLOCK(this, FALSE, "ru db_scheme::find_index");
        }
        return (FALSE);
}

/* Print out description of table. */
void
db_scheme::print()
{
        int i;

        READLOCKV(this, "r db_scheme::print");
        for (i = 0; i < keys.keys_len; i++) {
                keys.keys_val[i].key_name->print();
                printf(
        "\tcolumn=%d, flags=0x%x, key record position=%d, max length=%d\n",
                        keys.keys_val[i].column_number,
                        keys.keys_val[i].key_flags,
                        keys.keys_val[i].where.start_column,
                        keys.keys_val[i].where.max_len);
                printf("\tdata record position=%d, max length=%d\n",
                        data.where.start_column, data.where.max_len);
        }
        printf("\tmaximum number of columns=%d\n", max_columns);
        READUNLOCKV(this, "ru db_scheme::print");
}