
/*
 *  Name:           query
 *  Input:          root node of index, root
 *                  search index key, searchKey
 *                  search non-key list, searchNonKey
 *                  validity check flag, checkValidity
 *                  output function pointer, outputQuery
 *  Output:         integer return code
 *  Return:         QUERY_SUCCESS, or
 *                  QUERY_INVALID_KEY_SEARCH_VALUE,
 *                  QUERY_INVALID_NON_KEY_SEARCH_VALUE
 *  Description:    The routine searchs the index and calls the outputQuery 
 *                  routine for each consistent data object found.  The routine 
 *                  first uses the R-Tree index to find individual leaf nodes 
 *                  which point to data objects which have index keys which are
 *                  consistent with the input search key.  The found data 
 *                  object's non-key attributes are then compared with the input
 *                  list of non-key search values for consistency.  The input 
 *                  list of non-key search values consist of the attribute code 
 *                  and a character sequence.  Two utility subroutines are used 
 *                  to check the validity of the input search values.  The input
 *                  is checked only when the validity input flag is set to TRUE 
 *                  which prevents multiple checks of the same data since this 
 *                  routine is applied recursively.  Note that the index is 
 *                  never altered by a query which means no error is fatal.  Two
 *                  utility subroutines are used to determine consistency which 
 *                  is intersection for the DIS application.  The utility 
 *                  subroutines are used to separate the specific hyper-cube 
 *                  dimension and character string from the general R-Tree 
 *                  algorithm.
 *
 *                  Once a consistent data object has been found, the input 
 *                  routine outputQuery() is called for this object.  It's 
 *                  expected that the outputQuery() routine will place some 
 *                  representation of the data object into an output buffer for 
 *                  the query response.  The query() routine does not define 
 *                  what the representation will be, which allows the calling 
 *                  program to determine the format and timing of the response 
 *                  display.
 *  Calls:          consistentKey()
 *                  consistentNonKey()
 *                  errorMessage()
 *                  validKey()
 *                  validNonKey()
 *      System:     
 *  Author:         M.L.Rivas
 *
 *  Revision History:
 *
 *  Date    Name            Revision
 *  ------- --------------- ------------------------------
 *  24May99 Matthew Rivas   Created
 *
 *	Copyright 1999, Atlantic Aerospace Electronics Corp.
 */

#include <assert.h>         /* for assert()                                 */
#include <stdlib.h>         /* for NULL definition                          */
#include "dataManagement.h" /* for primitive type definitions               */
#include "dataObject.h"     /* for DataAttribute and DataObject definitions */
#include "errorMessage.h"   /* for errorMessage() definition                */
#include "index.h"          /* for IndexNode and IndexEntry definitions     */
#include "indexKey.h"       /* for IndexKey definition                      */
#include "query.h"          /* for query return codes                       */

/*
 *  Function prototypes
 */
extern Boolean consistentKey( IndexKey *A, IndexKey *B );
extern Boolean consistentNonKey( Char *A, Char *B );
extern Boolean validIndexKey( IndexKey *key );
extern Boolean validAttributes( DataAttribute *attributes );

Int query( IndexNode *node,                     /*  current node of index   */
           IndexKey *searchKey,                 /*  index key search values */
           DataAttribute *searchNonKey,         /*  non-key search values   */
           Boolean checkValidity,               /*  flag to check validity  */
           void (*outputQuery)( DataObject *) ) /*  output valid object     */
{   /* beginning of query() */
    static Char name[] = "query";

    assert( node );
    assert( searchKey );
    assert( !( checkValidity != TRUE && checkValidity != FALSE ) );

    /*
     *  If flag is set, check validity of key and non-key values.
     */
    if ( checkValidity == TRUE ) {
        if ( validIndexKey( searchKey ) == FALSE ) {
            errorMessage( "invalid index key search values", REPLACE );
            errorMessage( name, PREPEND );
            return ( QUERY_INVALID_KEY_SEARCH_VALUE );
        }   /*  end validity check of key values    */
        else if ( validAttributes( searchNonKey ) == FALSE ) {
            errorMessage( "invalid non-key search values", REPLACE );
            errorMessage( name, PREPEND );
            return ( QUERY_INVALID_NON_KEY_SEARCH_VALUE );
        }   /*  end validity check of non-key values    */
    }   /*  end of checkValidity == TRUE    */

    /*
     *  The routine is applied recursively so the current node may or may not be
     *  a leaf node.  If it is a leaf node, the child referenced by the entries 
     *  residing on the node are data objects.  If it is not a leaf node, the 
     *  child referenced by the entries are other nodes.  So if the current 
     *  level is not a leaf, recursively call the query routine on each 
     *  consistent entry.
     */
    if ( node->level > LEAF ) {
        IndexEntry *entry;  /*  temp entry for looping through list */
        
        /*
         *  Loop through each entry on current node and query each consistent 
         *  child node.  Note that only the key values are available for 
         *  consistency checks at any level greater than the LEAF level.
         */
        for ( entry = node->entries; entry != NULL; entry = entry->next ) {
            if ( consistentKey( &entry->key, searchKey ) == TRUE ) {
                query( entry->child.node, searchKey, searchNonKey, FALSE,
                       outputQuery );
            }   /*  end of branch which is consistent   */
        }   /*  end of loop for entry   */
    }   /*  end of if ( node->level > LEAF ) */
    else {
        IndexEntry *entry;  /*  temp entry for looping through list */
        
        /*
         *  Loop through each entry on current node and query each consistent 
         *  child node.  The first consistency check is made on the key value.  
         *  If the key values are consistent, then the data object is checked 
         *  for its non-key values.  A temporary upperBound value is set to 
         *  prevent out-of-range checks on the three types of data objects.
         */
        for ( entry = node->entries; entry != NULL; entry = entry->next ) {
            if ( consistentKey( &entry->key, searchKey ) == TRUE ) {
                DataAttribute *temp;            /*  attribute for list loop */
                DataObject    *object;          /*  allows easier reading   */
                Int           upperBound;       /*  prevents out-of-range   */
                Boolean       acceptanceFlag;   /* flag to output object    */

                object = entry->child.dataObject;

                upperBound = 0;
                if ( object->type == SMALL ) {
                    upperBound = NUM_OF_SMALL_ATTRIBUTES;
                }   /*  end of type == SMALL    */
                else if ( object->type == MEDIUM ) {
                    upperBound = NUM_OF_MEDIUM_ATTRIBUTES;
                }   /*  end of type == MEDIUM   */
                else if ( object->type == LARGE ) {
                    upperBound = NUM_OF_LARGE_ATTRIBUTES;
                }   /*  end of type == LARGE    */

                /*
                 *  The loop checks each value of the non-key search list and 
                 *  compares that value for that specific attribute code to the 
                 *  value stored in the data object.  If all of the attributes 
                 *  are consistent, the flag is set to TRUE at the end of the 
                 *  loop, and the outputQuery routine is called for the data 
                 *  object.  If any of the attributes are not consistent, the 
                 *  flag is set to FALSE and the loop exits and the next entry 
                 *  is checked.
                 */
                acceptanceFlag = TRUE;
                temp = searchNonKey;
                while ( temp != NULL && acceptanceFlag == TRUE ) {
                    if ( temp->code < upperBound ) {
                        acceptanceFlag = consistentNonKey(
                            object->attributes[ temp->code ].value.nonKey,
                            temp->attribute.value.nonKey );
                    }   /*  end of code < upperBound    */
                    temp = temp->next;
                }   /*  end of loop through non-key search value list   */

                if ( acceptanceFlag == TRUE ) {
                    outputQuery( entry->child.dataObject );
                }   /*  end of acceptanceFlag == TRUE   */
            }   /*  end of if consistentKey == TRUE */
        }   /*  end of loop for entry   */
    }   /*  end of if ( node->level == LEAF )   */

    return ( QUERY_SUCCESS );
}   /*  end query() */