/**********************************************************************
// @@@ 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 @@@
**********************************************************************/
#ifndef NAFILESET_H
#define NAFILESET_H
/* -*-C++-*-
 *****************************************************************************
 *
 * File:         NAFileSet.h
 * Description:  A description of a file set, i.e., a set of files
 *               that implement a table, an index, a view, etc. 
 * Created:      12/20/95
 * Language:     C++
 *
 *
 *
 *
 *****************************************************************************
 */

// -----------------------------------------------------------------------

#include "Collections.h"
#include "NAColumn.h"
#include "ObjectNames.h"

// -----------------------------------------------------------------------
// contents of this file
// -----------------------------------------------------------------------
class NAFileSet;
class NAFileSetList;

// -----------------------------------------------------------------------
// Forward declarations
// -----------------------------------------------------------------------
class PartitioningFunction;
class TrafDesc;
class HHDFSTableStats;
class HbaseCreateOption;

// -----------------------------------------------------------------------
// An enumerated type that describes how data is organized in EVERY
// file that belongs to this file set.
// A key sequenced file is implemented by a B+ tree.
// A hash file contains records whose key columns compute to the 
// same hash value when the hash function that is used for 
// distributing the data is applied to them.
// -----------------------------------------------------------------------
enum FileOrganizationEnum 
{
  KEY_SEQUENCED_FILE,
  HASH_FILE
};

// -----------------------------------------------------------------------
// A NAFileSet object describes common attributes of a set of files
// that are used for implementing a base table, a single-table or a
// multi-table index, a materialized view or any other SQL object.
// -----------------------------------------------------------------------
class NAFileSet : public NABasicObject
{
  friend class NATable;
public:

  // ---------------------------------------------------------------------
  // Constructor functions
  // ---------------------------------------------------------------------
  NAFileSet(const QualifiedName & fileSetName,
	    const QualifiedName & extFileSetObj,
	    const NAString & extFileSetName,
	    enum FileOrganizationEnum org,
	    NABoolean isSystemTable,
	    Lng32 countOfFiles,
	    Cardinality estimatedNumberOfRecords,
	    Lng32 recordLength,
	    Lng32 blockSize,
	    Int32 indexLevels,
	    const NAColumnArray & allColumns,
	    const NAColumnArray & indexKeyColumns,
	    const NAColumnArray & horizontalPartKeyColumns,
	    PartitioningFunction * forHorizontalPartitioning,
	    short keytag,
	    Int64 redefTime,
	    NABoolean audited,
	    NABoolean auditCompressed,
	    NABoolean compressed,
	    ComCompressionType dcompressed,
	    NABoolean icompressed,
	    NABoolean buffered,
	    NABoolean clearOnPurge,
	    NABoolean packedRows,
            NABoolean hasRemotePartition,
	    NABoolean isUniqueSecondaryIndex,
            NABoolean isDecoupledRangePartitioned,
            Lng32 fileCode,
	    NABoolean isVolatile,
	    NABoolean inMemObjectDefn,
            Int64 indexUID,
            TrafDesc *keysDesc,
            HHDFSTableStats *hHDFSTableStats,
            Lng32 numSaltPartns,
            NAList<HbaseCreateOption*>* hbaseCreateOptions,
            CollHeap * h=0);

  // copy ctor
  NAFileSet (const NAFileSet & orig, CollHeap * h=0) ; //not written

  virtual ~NAFileSet();
  
  // ---------------------------------------------------------------------
  // Accessor functions
  // ---------------------------------------------------------------------
  const QualifiedName & getFileSetName() const	    { return fileSetName_; }
  const NAString      & getExtFileSetName() const   { return extFileSetName_;}
  const QualifiedName & getExtFileSetObj() const    { return extFileSetObj_; }
  const QualifiedName & getRandomPartition() const;

  const NAColumnArray & getAllColumns() const      { return allColumns_; }

  // Method to get counts for various types of columns.
  // - excludeNonUserSpecifiedAlternateIndexColumns returns the number
  //   of columns in an index that are specified directly by the
  //   user (salt included unless exludeSystemColumns is also set).
  //   Returns 0 when called on the clusteringindex.
  // - Other options should be self-explanatory.
  Int32 getCountOfColumns(
       NABoolean excludeNonKeyColumns = FALSE,
       NABoolean excludeNonUserSpecifiedAlternateIndexColumns = FALSE,
       NABoolean excludeSystemColumns = TRUE,
       NABoolean excludeAlwaysComputedSystemColumns = FALSE) const;

  const NAColumnArray & getIndexKeyColumns() const
                                              { return indexKeyColumns_; }

  const TrafDesc * getKeysDesc() const { return keysDesc_; }
  TrafDesc * getKeysDesc() { return keysDesc_; }

  Lng32 getCountOfFiles() const                  { return countOfFiles_; }

  Cardinality getEstimatedNumberOfRecords() const
                                     { return estimatedNumberOfRecords_; }
  Lng32 getRecordLength() const             { return recordLength_; }
  Lng32 getLockLength() const             { return lockLength_; }
  Lng32 getKeyLength();
  Lng32 getEncodedKeyLength();
  Lng32 getBlockSize() const                   { return blockSize_; }

  Int32 getIndexLevels() const                   { return indexLevels_; }

  Lng32 getPackingScheme() const     { return packingScheme_; }
  Lng32 getPackingFactor() const     { return packingFactor_; }

  Lng32 getFileCode() const { return fileCode_; }

  const Int64 &getIndexUID() const { return indexUID_; }
  Int64 &getIndexUID() { return indexUID_; }

  const HHDFSTableStats *getHHDFSTableStats() const { return hHDFSTableStats_; }
  HHDFSTableStats *getHHDFSTableStats()             { return hHDFSTableStats_; }

  Lng32 numSaltPartns() const { return numSaltPartns_; } 
  NAList<HbaseCreateOption*> * hbaseCreateOptions() const
    { return hbaseCreateOptions_;}

  Lng32 numMaxVersions() const { return numMaxVersions_; } 

  // ---------------------------------------------------------------------
  // Mutator functions
  // ---------------------------------------------------------------------

  void setCountOfFiles (Lng32 count)   {countOfFiles_ = count;}
  void setIndexLevels (Int32 numLevels) {indexLevels_ = numLevels;}
  void setHasRemotePartitions(NABoolean flag) {hasRemotePartition_ = flag;}
  void setPartitioningFunction(PartitioningFunction * pFunc)
                                                     {partFunc_ = pFunc;}
  void setFileSetName(QualifiedName & rhs) {fileSetName_ = rhs;}
  void setEstimatedNumberOfRecords(Cardinality newEstimate)
                     { estimatedNumberOfRecords_ = newEstimate; }

  // ---------------------------------------------------------------------
  // Query the file organization.
  // ---------------------------------------------------------------------
  NABoolean isKeySequenced() const  
                     { return (fileOrganization_ == KEY_SEQUENCED_FILE); }
  NABoolean isHashed() const      
                              { return (fileOrganization_ == HASH_FILE); }
  NABoolean isSyskeyLeading() const;
  Int32 getSysKeyPosition()  const;
  NABoolean hasSyskey() const;
  NABoolean hasOnlySyskey() const;
  NABoolean hasSingleColVarcharKey() const;

  NABoolean isDecoupledRangePartitioned() const
                    { return isDecoupledRangePartitioned_; }
 
  // ---------------------------------------------------------------------
  // Query miscellaneous flags.
  // ---------------------------------------------------------------------
  NABoolean isAudited() const			      { return audited_; }
  NABoolean isAuditCompressed() const	      { return auditCompressed_; }
  NABoolean isCompressed() const	      { return compressed_; }
  ComCompressionType getDCompressed() const   { return dcompressed_; }
  NABoolean isICompressed() const	      { return icompressed_; }
  NABoolean isBuffered() const	              { return buffered_; }
  NABoolean isClearOnPurge() const	      { return clearOnPurge_; }
  NABoolean isSystemTable() const		{ return isSystemTable_; }
  NABoolean isRemoteIndexGone() const         { return thisRemoteIndexGone_;}
  void      setRemoteIndexGone()              { thisRemoteIndexGone_=TRUE;}

  short getKeytag() const 		       { return keytag_; }

  const Int64 &getRedefTime() const		    { return redefTime_; }

  // ---------------------------------------------------------------------
  // Query the partitioning function.
  // ---------------------------------------------------------------------
  NABoolean isPartitioned() const;

  Lng32 getCountOfPartitions() const;

  NABoolean containsPartition(const NAString &partitionName) const;
  
  const NAColumnArray & getPartitioningKeyColumns() const
                                       { return partitioningKeyColumns_; }

  NAString getBestPartitioningKeyColumns(char separator) const;

  PartitioningFunction * getPartitioningFunction() const
                                                     { return partFunc_; }

  NABoolean isPacked() const { return packedRows_; };
  
  NABoolean hasRemotePartitions() const { return hasRemotePartition_; };

  // Get and Set methods for the bitFlags_.
  NABoolean uniqueIndex() const { return (bitFlags_ & UNIQUE_INDEX)  != 0; }
  void setUniqueIndex(NABoolean v)      
           { (v ? bitFlags_ |= UNIQUE_INDEX : bitFlags_ &= ~UNIQUE_INDEX); }

  NABoolean notAvailable() const { return (bitFlags_ & NOT_AVAILABLE)  != 0; }
  void setNotAvailable(NABoolean v)      
           { (v ? bitFlags_ |= NOT_AVAILABLE : bitFlags_ &= ~NOT_AVAILABLE); }

  NABoolean isVolatile() const{return (bitFlags_ & IS_VOLATILE)  != 0; }
  void setIsVolatile(NABoolean v)      
           { (v ? bitFlags_ |= IS_VOLATILE : bitFlags_ &= ~IS_VOLATILE); }

  const NABoolean isInMemoryObjectDefn() const{return (bitFlags_ & IN_MEMORY_OBJECT_DEFN)  != 0; }
  void setInMemoryObjectDefn(NABoolean v)      
           { (v ? bitFlags_ |= IN_MEMORY_OBJECT_DEFN : bitFlags_ &= ~IN_MEMORY_OBJECT_DEFN); }


  NABoolean isCreatedExplicitly() const{return (bitFlags_ & IS_EXPLICIT_INDEX)  != 0; }
  void setIsCreatedExplicitly(NABoolean v)      
           { (v ? bitFlags_ |= IS_EXPLICIT_INDEX : bitFlags_ &= ~IS_EXPLICIT_INDEX); }

  //For NATable caching, clear up the statement specific stuff
  //so that this can be used for following statements
  void resetAfterStatement();

  //For NATable caching, prepare for use by a statement.
  void setupForStatement();

  NABoolean isSqlmxAlignedRowFormat() const { return rowFormat_ == COM_ALIGNED_FORMAT_TYPE; }

  void setRowFormat(ComRowFormat rowFormat) { rowFormat_ = rowFormat; }

private:

  // ---------------------------------------------------------------------
  // The fully qualified PHYSICAL name for the file set,
  // e.g. { "\NSK.$VOL", ZSDNGUOF, T5AB0000 }.
  // ---------------------------------------------------------------------
  QualifiedName fileSetName_;

  // ---------------------------------------------------------------------
  // The EXTERNAL name of fileset, as specified by the user.
  // For ARK tables, this is the ANSI name of the index/basetable specified
  // when the index/basetable was created (the preceding field, fileSetName_,
  // thus represents the actual physical name of the index).
  //
  // For SQL/MP or simulator tables, both fileSetName_ and extFileSetName_
  // fields are nearly the same, just formatted differently (one without
  // double-quote delimiters, one with).
  // ---------------------------------------------------------------------
  NAString extFileSetName_;
  QualifiedName extFileSetObj_;

  // ---------------------------------------------------------------------
  // File organization.
  // The following enum describes how records are organized in each
  // file of this file set.
  // ---------------------------------------------------------------------
  FileOrganizationEnum fileOrganization_;
  
  // ---------------------------------------------------------------------
  // The number of files that belong to this file set.
  // (May need a set of file names/NAFile also/instead someday.)
  // ---------------------------------------------------------------------
  Lng32 countOfFiles_;

  // ---------------------------------------------------------------------
  // The number of records can either be a value that is computed by
  // UPDATE STATISTICS or may be estimated by examining the EOFs of
  // each file in this file set and accumulating an estimate.
  // ---------------------------------------------------------------------
  Cardinality estimatedNumberOfRecords_;
  
  // ---------------------------------------------------------------------
  // Record length in bytes.
  // ---------------------------------------------------------------------
  Lng32 recordLength_;

  // ---------------------------------------------------------------------
  // Key length in bytes.
  //----------------------------------------------------------------------
  Lng32 keyLength_;

  // ---------------------------------------------------------------------
  // Encoded key length in bytes.
  //----------------------------------------------------------------------
  Lng32 encodedKeyLength_;

  // ---------------------------------------------------------------------
  // Lock length in bytes.
  //----------------------------------------------------------------------
  Lng32 lockLength_;

  // ---------------------------------------------------------------------
  // Filecode.
  // ---------------------------------------------------------------------
  Lng32 fileCode_;

  // ---------------------------------------------------------------------
  // Size of a page (block) that is a contant for every file that 
  // belongs to this file set. It is expressed in bytes.
  // ---------------------------------------------------------------------
  Lng32 blockSize_;
  
  // ----------------------------------------------------------------------
  // Packing information. Packing scheme: describes version of packed
  // record format used in this file set's packed records.
  // Packing factor: number of unpacked (logical) rows per packed (physical) record.
  // ----------------------------------------------------------------------
  Lng32      packingScheme_;
  Lng32      packingFactor_;

  // ---------------------------------------------------------------------
  // since the index levels could be different for every file that  
  // belongs to this file set, we probably should save index levels
  // per file. But, for now, we save the maximum of the index levels
  // of the files that belong to this fileset.                      
  // ---------------------------------------------------------------------
  Int32 indexLevels_;
  
  // ---------------------------------------------------------------------
  // Array of all the columns that appear in each record in every file
  // that belongs to this file set.
  // ---------------------------------------------------------------------
  NAColumnArray allColumns_;

  // ---------------------------------------------------------------------
  // Array of key columns that implement a B+ tree or hash index per
  // file that belongs to this file set.
  // ---------------------------------------------------------------------
  NAColumnArray indexKeyColumns_;

  // uid for index
  Int64 indexUID_;

  TrafDesc *keysDesc_;  // needed for parallel label operations.

  // ---------------------------------------------------------------------
  // Horizontal partitioning:
  // The partitioning function describes how data is distributed 
  // amongst the files contained in this file set. Note that the scheme
  // for distributing the data is orthogonal to the scheme for 
  // organizing records within a file.
  // ---------------------------------------------------------------------

  // --------------------------------------------------------------------
  // For persistent range or hash partitioned data, the partitioning 
  // key is expressed as a list of NAColumns. The list represents the 
  // sequence in which the key columns appear in the declaration of 
  // the partitioning scheme such as the SQL CREATE TABLE statement. 
  // It does not imply an ordering on the key columns. If an ordering 
  // exists, it is implemented by a partitioning function. 
  // 
  // A NAFileSet need not contain a partitioning key.
  // --------------------------------------------------------------------
  NAColumnArray partitioningKeyColumns_;
  
  PartitioningFunction * partFunc_;

  // ---------------------------------------------------------------------
  // Some day we may support arbitrary queries, then an additional
  // data member could hold the relational expression that defines
  // the content of the file set. The file set columns would then refer
  // to the result of this expression.
  // ---------------------------------------------------------------------
  // RelExpr *fileSetQuery_; // unbound fileSet definition (no value ids)

  // ---------------------------------------------------------------------
  // This member is poorly named.  For all base tables (MP or MX),
  // i.e. for all primary index NAFilesets, this is zero.
  // For all secondary indexes (MP or MX), this is nonzero.
  // ---------------------------------------------------------------------
  short keytag_;
  
  // ---------------------------------------------------------------------
  // Catalog timestamp for this fileset. Each index gets its own timestamp.
  // ---------------------------------------------------------------------
  Int64 redefTime_;

  // ---------------------------------------------------------------------
  // Miscellaneous flags
  // ---------------------------------------------------------------------
  NABoolean audited_;
  NABoolean auditCompressed_;
  NABoolean compressed_; 
  ComCompressionType dcompressed_;
  NABoolean icompressed_;
  NABoolean buffered_;
  NABoolean clearOnPurge_;
  NABoolean isSystemTable_;
  NABoolean packedRows_;
  NABoolean hasRemotePartition_;
  NABoolean setupForStatement_;
  NABoolean resetAfterStatement_;
  NABoolean isDecoupledRangePartitioned_;

  // ---------------------------------------------------------------------
  // Miscellaneous Bit flags. It reduces compiler memory consumption +
  // no need to recompile the world on adding a new flag.
  // ---------------------------------------------------------------------
  enum BitFlags
  {
    // Set, if this is a unique secondary index.
    UNIQUE_INDEX = 0x0001,

    // Set, if this index is not available.
    // Could be due to no populate, or if an mv has not been
    // refreshed, or others...
    NOT_AVAILABLE = 0x0002,

    // if this is a volatile index
    IS_VOLATILE = 0x0004,

    // if set, indicates that this object is created in mxcmp/catman
    // memory and not available in metadata or disk.
    // Used to test out plans on tables/indexes without actually
    // creating them.
    IN_MEMORY_OBJECT_DEFN = 0x0008,

    // if this index was explicitly created by user and not internally
    // created to implement a unique constraint.
    IS_EXPLICIT_INDEX = 0x00010
    
      
  };
  ULng32 bitFlags_;

  NABoolean thisRemoteIndexGone_;

  // ---------------------------------------------------------------------
  // HDFS file-level stats for Hive tables
  // ---------------------------------------------------------------------
  HHDFSTableStats *hHDFSTableStats_;

  // number of salted partitions specified at table create time.
  Lng32 numSaltPartns_;

  // if table was created with max versions greater than 1 using
  // hbase_options clause.
  Lng32 numMaxVersions_;

  NAList<HbaseCreateOption*> * hbaseCreateOptions_;

  ComRowFormat rowFormat_; 
  
};

class NAFileSetList : public LIST(NAFileSet *)
{
public:
  NAFileSetList(CollHeap* h/*=0*/) :  LIST(NAFileSet *)(h) {  }
};

#endif /* NAFILESET_H */