| /********************************************************************** |
| // @@@ START COPYRIGHT @@@ |
| // |
| // Licensed to the Apache Software Foundation (ASF) under one |
| // or more contributor license agreements. See the NOTICE file |
| // distributed with this work for additional information |
| // regarding copyright ownership. The ASF licenses this file |
| // to you under the Apache License, Version 2.0 (the |
| // "License"); you may not use this file except in compliance |
| // with the License. You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, |
| // software distributed under the License is distributed on an |
| // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| // KIND, either express or implied. See the License for the |
| // specific language governing permissions and limitations |
| // under the License. |
| // |
| // @@@ END COPYRIGHT @@@ |
| **********************************************************************/ |
| /* -*-C++-*- |
| **************************************************************************** |
| * |
| * File: ComQueue.h |
| * Description: |
| * |
| * Created: 5/6/98 |
| * Language: C++ |
| * |
| * |
| * |
| * |
| **************************************************************************** |
| */ |
| |
| #ifndef COMQUEUE_H |
| #define COMQUEUE_H |
| |
| #include "NABasicObject.h" |
| #include "NAVersionedObject.h" |
| |
| |
| // --------------------------------------------------------------------- |
| // The PackQueue macros provide a way to really pack the "whole" queue. |
| // This includes the backbone of the queue as well as objects referenced |
| // by the (void *) in the Q_Entry's. The real class identity of those |
| // objects is passed as a parameter to the macros. Depending on whether |
| // those objects belong to a derived class of NAVersionedObject or not, |
| // either drivePack() or pack() will be called. Note that queuePtr has |
| // to be of type "QueuePtr". |
| // --------------------------------------------------------------------- |
| |
| #define PackQueueOfNAVersionedObjects(queuePtr, space, Type) \ |
| if (queuePtr) \ |
| { \ |
| Type * entry; \ |
| queuePtr->position(); \ |
| while ((entry = (Type *)(queuePtr->getNext())) != NULL) \ |
| entry->drivePack(space); \ |
| queuePtr.pack(space); \ |
| } |
| |
| #define PackQueueOfNonNAVersionedObjects(queuePtr, space, Type) \ |
| if (queuePtr) \ |
| { \ |
| Type * entry; \ |
| queuePtr->position(); \ |
| while ((entry = (Type *)(queuePtr->getNext())) != NULL) \ |
| entry->pack(space); \ |
| queuePtr.pack(space); \ |
| } |
| |
| #define UnpackQueueOfNAVersionedObjects(queuePtr, base, Type, Reallocator) \ |
| if (queuePtr) \ |
| { \ |
| if(queuePtr.unpack(base,reallocator)) return -1; \ |
| Type * entry; \ |
| queuePtr->position(); \ |
| while ((entry = (Type *)(queuePtr->getNext())) != NULL) \ |
| { \ |
| Type obj; \ |
| entry->driveUnpack(base,&obj,reallocator); \ |
| } \ |
| } |
| |
| #define UnpackQueueOfNonNAVersionedObjects(queuePtr, base, Type) \ |
| if (queuePtr) \ |
| { \ |
| if(queuePtr.unpack(base)) return -1; \ |
| Type * entry; \ |
| queuePtr->position(); \ |
| while ((entry = (Type *)(queuePtr->getNext())) != NULL) \ |
| { \ |
| entry->fixupVTblPtr(); \ |
| entry->unpack(base); \ |
| } \ |
| } |
| |
| |
| // --------------------------------------------------------------------- |
| // Template instantiation to produce a 64-bit pointer emulator class |
| // for Q_Entry |
| // --------------------------------------------------------------------- |
| class Q_Entry; |
| typedef NAOpenObjectPtrTempl<Q_Entry> Q_EntryPtr; |
| |
| class Q_Entry |
| { |
| friend class Queue; |
| |
| NABasicPtr entry; // 00-07 |
| Q_EntryPtr prev; // 08-15 |
| Q_EntryPtr next; // 16-23 |
| UInt32 packedLength_; // 24-27 |
| char fillersQ_Entry_[20]; // 28-47 |
| |
| public: |
| Q_Entry(void * entry_, Q_Entry * prev_, Q_Entry * next_); |
| |
| ~Q_Entry(); |
| |
| Long pack(void *space); |
| Lng32 unpack(void *base); |
| |
| ULng32 packedLength() { return packedLength_; } |
| }; |
| |
| class Queue : public NAVersionedObject |
| { |
| Q_EntryPtr head; // 00-07 |
| Q_EntryPtr tail; // 08-15 |
| Q_EntryPtr curr; // 16-23 |
| |
| CollHeap *heap_; |
| |
| Int32 numEntries_; // 32-35 |
| |
| // length of queue in 'packed' (contiguous) form. |
| // This field is updated whenever a new queue entry is added (removed). |
| UInt32 packedLength_; // 36-39 |
| |
| UInt16 flags_; // 40-41 |
| char fillersQueue_[14]; // 42-55 |
| |
| enum { |
| // if set, then remove doesn't deletes Q_Entry, only makes the |
| // entry pointer NULL. |
| // Insert is done at the first empty Q_Entry. |
| // remove removes the head entry and moves it to the end |
| // of the list. |
| DO_SPACE_OPT = 0x0001 |
| }; |
| |
| public: |
| Queue(); |
| |
| |
| // --------------------------------------------------------------------- |
| // Redefine virtual functions required for Versioning. |
| //---------------------------------------------------------------------- |
| virtual unsigned char getClassVersionID() |
| { |
| return 1; |
| } |
| |
| virtual void populateImageVersionIDArray() |
| { |
| setImageVersionID(0,getClassVersionID()); |
| } |
| |
| virtual short getClassSize() { return (short)sizeof(Queue); } |
| |
| Queue(CollHeap * heap); |
| |
| ~Queue(); |
| |
| // inserts at tail |
| void insert(const void * entry_, ULng32 entryPackedLength = 0); |
| |
| // inserts at tail, returns addr of Queue entry inserted |
| void insert(const void * entry_, ULng32 entryPackedLength, |
| void ** queueEntry); |
| |
| // returns the head entry |
| void * get(); |
| |
| // returns the i'th entry. 0 based. First entry is i = 0 |
| void * get(ULng32 i); |
| |
| // returns the head entry |
| void * getHead(); |
| |
| // returns the tail(last) entry |
| void * getTail(); |
| |
| // positions on the head entry |
| void position(); |
| |
| // positions on a specified Queue entry |
| void position(void * queueEntry); |
| |
| // returns the current entry |
| void * getCurr(); |
| |
| // advances the current entry |
| void advance(); |
| |
| // returns the current entry and advances curr |
| void * getNext(); |
| |
| // returns -1, if all entries have been returned. |
| short atEnd(); |
| |
| // removes the head entry |
| void remove(); |
| |
| // removes the head entry |
| void removeHead() { remove(); }; |
| |
| // removes the tail entry |
| void removeTail(); |
| |
| void removeWithSpaceOpt(); |
| |
| // removes the 'entry' entry |
| NABoolean remove(void * entry); |
| |
| |
| virtual Long pack(void * space); |
| |
| virtual Lng32 unpack(void * base, void * reallocator); |
| |
| // returns -1, if queue is empty. Otherwise, returns 0. |
| Int32 isEmpty() |
| { |
| return ((numEntries() == 0) ? -1 : 0); |
| } |
| |
| Lng32 numEntries() { return numEntries_;} |
| |
| Lng32 entries() { return numEntries();} |
| |
| ULng32 packedLength() { return packedLength_; } |
| |
| |
| void setDoSpaceOpt(short v) {(v ? flags_ |= DO_SPACE_OPT : flags_ &= ~DO_SPACE_OPT); }; |
| NABoolean doSpaceOpt() { return (flags_ & DO_SPACE_OPT) != 0; }; |
| |
| }; |
| |
| // --------------------------------------------------------------------- |
| // Template instantiation to produce a 64-bit pointer emulator class |
| // for Queue |
| // --------------------------------------------------------------------- |
| typedef NAVersionedObjectPtrTempl<Queue> QueuePtr; |
| |
| // A HashQueue is basically a container which is accessed by |
| // hashing. It is introduced here to speed up the statement |
| // and descriptor lookup in the sqlcli. The statement- and |
| // descriptor lists were originally implemented as Queues. Lookup |
| // was always just a sequential search in this list. Note |
| // that the following is a quick and dirty implementation |
| // to eliviate this performance problem. If we would only |
| // have more time (sigh), a better design would be a template |
| // based implementation of containers (lists, arrays, queues, |
| // stacks, you name it) for the executor similar to the collections |
| // in the compiler. |
| |
| class HashQueueEntry { |
| friend class HashQueue; |
| |
| public: |
| HashQueueEntry(void * entry, |
| HashQueueEntry * prev, |
| HashQueueEntry * next, |
| ULng32 hashValue) |
| : entry_(entry), |
| prev_(prev), |
| next_(next), |
| hashValue_(hashValue) { |
| }; |
| |
| ~HashQueueEntry() { |
| }; |
| |
| private: |
| HashQueueEntry * prev_; |
| HashQueueEntry * next_; |
| void * entry_; |
| ULng32 hashValue_; |
| }; |
| |
| |
| class HashQueue : public NABasicObject { |
| public: |
| HashQueue(CollHeap * heap, ULng32 hashTableSize = 513); |
| |
| HashQueue(const NABoolean shadowCopy, |
| const HashQueue &other); |
| |
| ~HashQueue(); |
| |
| ULng32 entries() { return entries_; } |
| |
| ULng32 size() { return hashTableSize_; } |
| |
| void insert(const char * data, ULng32 dataLength, void * entry); |
| |
| // position by hashing |
| void position(const char * data, ULng32 dataLength); |
| |
| // position globally |
| void position(); |
| |
| void * getNext(); |
| |
| // returns the current entry |
| void * getCurr(); |
| |
| // advances the current entry |
| void advance(); |
| |
| void remove(void * entry); |
| |
| // To remove the last returned entry via getNext() in case of global scan |
| // of hash queue |
| void remove(); |
| |
| // To remove the entry by passing in the hashing fields and the corresponding entry |
| void remove(const char *data, ULng32 dataLength, void *entry); |
| |
| Lng32 numEntries() { return (Lng32)entries_;} |
| |
| NABoolean sequentialAdd() { return (flags_ & SEQUENTIAL_ADD) != 0; } |
| |
| void setSequentialAdd(NABoolean v) |
| { (v ? flags_ |= SEQUENTIAL_ADD : flags_ &= ~SEQUENTIAL_ADD); } |
| Int32 isEmpty() { return ((entries_ == 0) ? -1 : 0); } |
| |
| private: |
| enum Flags |
| { |
| // add hash entries in a sequential order (the same order in which |
| // they are inserted). |
| SEQUENTIAL_ADD = 0x0001 |
| }; |
| |
| ULng32 entries_; // number of entries in this HashQueue |
| ULng32 hashTableSize_; // size of the hash table |
| HashQueueEntry ** hashTable_; // the hash table itself |
| HashQueueEntry * lastReturned_; // the last entry returned by getNext() |
| HashQueueEntry * current_; // points to the current entry |
| ULng32 currentChain_; // the chain were current_ is located |
| ULng32 hashValue_; // hash value of the last position |
| NABoolean globalScan_; // if true, getNext ignores hashValue |
| CollHeap * heap_; // the heap a HashQueue allocates from |
| NABoolean shadowCopy_; // TRUE if constructed by shadow copy |
| |
| ULng32 flags_; |
| |
| void getHashValue(const char * data, ULng32 dataLength); |
| |
| void removeLastReturned(); |
| }; |
| |
| class SyncHashQueue : public HashQueue { |
| public: |
| SyncHashQueue(CollHeap * heap, ULng32 hashTableSize = 513); |
| void position(const char * data, ULng32 dataLength); |
| void position(); |
| void remove(void * entry); |
| void remove(); |
| void remove(const char *data, ULng32 dataLength, void *entry); |
| void insert(const char * data, ULng32 dataLength, void * entry); |
| }; |
| |
| |
| #endif |
| |
