/**********************************************************************
// @@@ 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 _SIMPLE_SCAN_OPTIMIZER_H
#define _SIMPLE_SCAN_OPTIMIZER_H
/* -*-C++-*-
 *****************************************************************************
 *
 * File:         SimpleScanOptimizer.h
 * Description:  Class SimpleFileScanOptimzer
 *               Simplified Costing for Scan operators
 * Created:      04/2003
 * Language:     C++
 *
 *****************************************************************************
 */

#pragma once

#include "ScanOptimizer.h"

// -----------------------------------------------------------------------
// The class SimpleFileScanOptimizer performs several actions:
// 1.- Builds a key for the access method
// 2.- Computes the cost for the access method
// -----------------------------------------------------------------------
class SimpleFileScanOptimizer : public ScanOptimizer
{
  friend class MDAMCostWA;
  friend class MDAMOptimalDisjunctPrefixWA;
  friend class MdamTrace;
public:

  // Constructor
  //
  SimpleFileScanOptimizer(const FileScan& assocFileScan
                          ,const CostScalar& resultSetCardinality
                          ,const Context& myContext
                          ,const ValueIdSet &externalInputs);

  // Copy constructor, never called, not implemented!
  //
  SimpleFileScanOptimizer(const SimpleFileScanOptimizer &sfso, CollHeap *h=0); 

  // Destructor
  //
  virtual ~SimpleFileScanOptimizer();

  // -----------------------------------------------------------------------
  // optimize performs several actions:
  // 1.- Creates the Search key
  // 2.- Computes and returns the cost of the access method.
  // 3.- Computes the number of blocks to read per access.
  // -----------------------------------------------------------------------
  virtual Cost * optimize(SearchKey*& searchKeyPtr   // out
			  ,MdamKey*&  mdamKeyPtr     // out
			  );

  // Compute the Cost for this single subset Scan using the simple costing model.
  // OUTPUTS:
  // Return - A NON-NULL Cost* representing the Cost for this scan node
  //
  // Side-Affects - computes and sets the numberOfBlocksToReadPerAccess_
  // data member of ScanOptimizer.  This value will be captured by the
  // FileScan node and passed to DP2 by the executor, DP2 uses it to
  // decide whether it will do read ahead or not.
  //
  Cost* scmComputeCostForSingleSubset();

  // Return the cached value for single subset size
  // The size of the single subset scanned by this Scan node.
  // Computed and cached by computeSingleSubsetSize()
  //
  inline const CostScalar &getSingleSubsetSize() const
                                                  { return singleSubsetSize_; }

private:

  // Construct the Search Key (MDAM or Single Subset)
  // (for now just the Single subset is considered)
  // Return pointer to search key and cache in local datamember.
  //
  SearchKey * constructSearchKey();

  // Return the cached pointer to the single subset search key.
  // The value was cached in constructSearchKey()
  //
  inline const SearchKey *getSearchKey() const { return searchKey_; }

  // Returns True if probes are in Full order otherwise False.
  // Sets a partialy order flag if probes are partially ordered.
  NABoolean
  ordersMatch(const InputPhysicalProperty* ipp,
            const IndexDesc* indexDesc,
            const ValueIdList* innerOrder,
            const ValueIdSet& charInputs,
            NABoolean partiallyInOrderOK,
            NABoolean& probesForceSynchronousAccess) ;

  // Compute the size (in rows) of the single subset scanned by this
  // scan node.  Cache the size in a local data member and also cache the
  // key predicates that define the single subset.
  //
  void computeSingleSubsetSize();

  // Return the cached set of single subset predicates.
  // The key predicates which define the single subset. 
  // Computed and cached by computeSingleSubsetSize()
  //
  inline const ValueIdSet &getSingleSubsetPreds() const
                                                 { return singleSubsetPreds_; }
  // Does the partitioning function associated with this scan
  // represent logical sub-partitioning.
  // (If so, we must consider the extra predicates from the
  // partitioning function)
  //
  NABoolean isLogicalSubPartitioned() const;

  // does leading key column has predicate?
  NABoolean isLeadingKeyColCovered();
  
  // Get any extra key predicates from the partitioning function.  The
  // partitioning function will provide extra key predicates when it
  // represents logical sub-partitioning.
  //
  const ValueIdSet& getPartitioningKeyPredicates() const;

  // Estimate the number of blocks that DP2 needs to read per access
  // for this Scan. This value is captured by the FileScan Node and
  // passed to DP2 by the executor, DP2 uses it to decide whether it
  // will do read ahead or not.
  //
  // Side-Affects - sets the numberOfBlocksToReadPerAccess_ data member
  // of ScanOptimizer.  
  // 
  void computeNumberOfBlocksToReadPerAccess(FileScanBasicCost *basicCostPtr);

  // Compute the Cost for this single subset Scan.
  //
  // Attempts to find an existing basic cost object which can be reused.
  //
  // Computes or resuses the first row and last row cost
  // vectors. (IOTime, CPUTime, SeekIOTime, IdleTime, numProbes)
  //
  // OUTPUTS:
  // Return - A NON-NULL Cost* representing the Cost for this scan node
  //
  // Side-Affects - computes and sets the numberOfBlocksToReadPerAccess_
  // data member of ScanOptimizer.  This value will be captured by the
  // FileScan node and passed to DP2 by the executor, DP2 uses it to
  // decide whether it will do read ahead or not.
  //
  Cost * computeCostForSingleSubset();

  // Determine if a shareable BasicCost object is available and usable.
  //
  // If a usable shared basic cost object is available, return it as is.
  //
  // If an unusable shared basic cost object is available, clear it and
  // return it as a nonshared basic cost object.
  //
  // If a shared basic cost object is not available, create a new one
  // and return it as a nonshared basic cost object.
  //
  // OUTPUTS: 
  // Return - NABoolean 
  //     - TRUE if a usable shared BasicCost object was available.
  //     - FALSE if a nonusable or new BasicCost object. 
  // *&basicCostPtr - set to the BasicCost object (shared or new)
  //
  NABoolean getSharedCostObject(FileScanBasicCost *&basicCostPtr);

  // Estimate the of seeks required for this single subset per scan
  // (partition).  Include the seeks required for accessing the index
  // blocks.
  //
  // Need to Seek to every index level except the root, plus need
  // to seek to first data block.
  //
  // Even if there are no rows expected in the result set, the
  // seeks still need to be performed.
  //
  // Do we need to seek twice this amount, once for the begin key
  // and once for the end key??????
  //
  // Returns: the number of seeks required for a single subset access to
  // a partition (this is equal to the number of index levels).
  //
  CostScalar estimateNumberOfSeeksPerScan(const CostScalar &seqKB) const;

  // Estimate the amount (in KBytes) of data read per scan (partition).
  // Include the index blocks which must be read.
  // 
  // Need to read to every index level except the root (always in cache?)
  //
  // Even if there are no rows expected in the result set, the index
  // blocks still need to be read.
  //
  // Do we need to read (some of) the index blocks twice, once for the
  // begin key and once for the end key??????
  //
  // Returns: the number of sequential KB read for a single subset access to
  // a partition (this include index and data blocks)
  //
  CostScalar estimateSeqKBReadPerScan() const;
  
  // Computes the cost vectors (First and Last Row) for this scan.
  // Computes:
  //    - KBytes
  //    - CPU Instructions
  //    -  Number of seeks
  //    - Idle time
  //    - number of probes
  // for both cost vectors.
  //
  // OUTPUTS: firstRow and lastRow SimpleCostVectors of the BasicCost
  // object are populated.
  //
  void computeCostVectors(FileScanBasicCost *basicCostPtr) const;

  // Computes the cost vectors for this scan using the simple costing model.
  // Computes:
  //    - number of tuples processed
  //    - number of tuples produced
  //    - sequential IOs
  //
  // OUTPUTS: lastRow SimpleCostVectors of the BasicCost
  // object are populated.
  //
  Cost* scmComputeCostVectors();
  Cost* scmComputeCostVectorsMultiProbes(); 
  Cost* scmComputeCostVectorsForHbase();
  Cost* scmComputeCostVectorsMultiProbesForHbase();

  // Compute the sequential KBytes accessed to produce the first and
  // last rows. 
  //
  // OUTPUTS: 
  // seqKBFR - The number of KBytes to be accessed to produce the first row.
  // seqKBLR - The number of KBytes to be accessed to produce the last row.
  //
  void estimateKB(CostScalar &seqKBFR, CostScalar &seqKBLR) const;

  // Estimate CPU Instructions (includes Per Request, Per Row and Per KB
  // number of CPU Instructions) for First and Last row accessed.
  //
  // Inputs: 
  //
  //    seeksPerScan - The number of seeks to be performed by this Scan
  //    (single partition).
  //
  //    rowsPerScanFR - The number of rows accessed by this scan before
  //    returning the first row (single partition)
  //
  //    rowsPerScanLR - The number of rows accessed by this scan (single
  //    partition)
  //
  //    seqKBFR - The number of KBytes to be accessed by this Scan to
  //    produce the first row (single partition).
  //
  //    seqKBLR - The number of KBytes to be accessed by this Scan to
  //    produce the last row (single partition).
  //
  // Outputs:
  // cpuInstructionsFR - Number of CPU instructions to access the First row.
  // cpuInstructionsLR - Number of CPU instructions to access the Last row.
  //
  void 
  estimateCPUInstructions(const CostScalar &seeksPerScan,
                          const CostScalar &rowsPerScanFR,
                          const CostScalar &rowsPerScanLR,
                          const CostScalar &selectedrowsPerScanFR,
                          const CostScalar &selectedrowsPerScanLR,
                          const CostScalar &seqKBFR,
                          const CostScalar &seqKBLR,
                          CostScalar &cpuInstructionsFR,
                          CostScalar &cpuInstructionsLR) const;

  // Estimate the number of CPU instructions used for each request.
  // This includes performing a binary search of each index block,
  // comparing the keys (byte compare of encoded keys) to find the
  // appropriate entry. And includes the default per request overhead.
  //
  // Return - the number of CPU instruction required to search the index
  // blocks to find the appropriate data block for this request.
  //
  CostScalar estimateCPUPerReqstInstrs() const;

  // Estimate the number of CPU instructions used to copy each row from
  // DP2 to the EXEINDP2.
  //
  // Return - the number of CPU instruction required to copy each row from
  // DP2 to the EXEINDP2.
  //
  CostScalar estimateCPUPerRowInstrs() const;

  // Estimate the per-row (of single subset) number of CPU instruction
  // required to evaluate the executor predicates
  //
  CostScalar estimateCPUExePredPerRowInstrs() const;

  // Estimate the per-seek CPU instructions.  This is the extra CPU cost
  // necessary for each seek.  For now this is just a default value.
  //
  CostScalar estimateCPUPerSeekInstrs() const;

  // Estimate the per-KB CPU instructions.  This is the extra CPU cost
  // necessary to copy each KB from DP2 to the EXEINDP2.  For now this
  // is just a default value.
  //
  CostScalar estimateCPUPerKBInstrs() const;

  // Estimate the amount of Idle time used by this Scan.
  //
  // CPUCOST_SUBSET_OPEN lumps together all the overhead needed to
  // set-up the access to each partition. Thus it is a blocking cost,
  // nothing can overlap with it.  Since scans are not blocking, by
  // definition, put the cost in idle time: this is the cost for
  // opening all the partitions but the first partition.  The first
  // partition is opened before the ScanOptimizer is called. During
  // opening the first partition, the necessary info on the file is
  // also acquired so it is more expensive and cannot be overlaid.
  // Root accounts for the cost of opening the first partition of all
  // the tables.
  //
  CostScalar estimateIdleTime() const;

  // Compute the number of blocks needed to hold the given number of
  // rows for this scan.  Assume that the rows are dense (no
  // fragmentation or slack).  Assume that there is a partial block at
  // each end of the subset.  This may overestimate the number of
  // blocks by 1, especially when there are very few rows.
  //
  CostScalar getNumBlocksForRows(const CostScalar &numRows) const;

  // Compute the estimated number of rows per scan (active partition),
  // based on the result set cardinality computed outside of the Scan
  // Optimizer and the number of active partitions for this Scan.
  //
  CostScalar getResultSetCardinalityPerScan() const;

  // Compute the number of rows of this Scan that will fit in a DP2 Buffer.
  //
  CostScalar getRowsInDP2Buffer() const;

  // Return the cached value of the recordSizeinKB for this Scan.  Value
  // was initialized from the IndexDesc of the associated FileScan.
  //
  inline const CostScalar &getRecordSizeInKb() const { return recordSizeInKb_;}

  // Return the cached value of the blockSizeinKB for this Scan.  Value
  // was initialized from the IndexDesc of the associated FileScan.
  //
  inline const CostScalar &getBlockSizeInKb() const { return blockSizeInKb_; }

  // Return the repeat Count for this scan.  The repeat count is an
  // estimate of the number of probes that this scan (partition) will
  // receive.
  // A return value of >= 1.0 indicates that this is a multiprobe scan
  // (below a nested join).
  // A return value of csZero (0.0) indicates that this is a single
  // probe scan.
  //
  CostScalar getRepeatCount() const;

  // Return the cached value of the estimatedRecordsPerBlock_ for this
  // Scan.  Value was initialized from the IndexDesc of the associated
  // FileScan.
  //
  inline const CostScalar &getEstimatedRecordsPerBlock() const
                                         { return estimatedRecordsPerBlock_; }

  // Addtional methods for Multiprobe scans
  //

  // Estimate the of seeks required for this all probes per scan
  // (partition).  Include the seeks required for accessing the index
  // blocks.
  //
  // Need to Seek to every index level except the root, plus need to
  // seek to first data block.
  //
  // Do we need to seek twice this amount, once for the begin key and
  // once for the end key??????
  //
  // Returns: the number of seeks required for all probes to access a
  // partition
  //
  CostScalar estimateNumberOfSeeksPerScanMultiProbe() const;

  // Estimate the amount (in KBytes) of data read per scan (partition).
  // Include the index blocks which must be read.
  // 
  // Consider these cases:
  //   Full Cache Benefit - Duplicate probes always get a cache hit.
  //   No Cache Benefit   - Duplicate probes never get a cache hit.
  //   Random access      - Duplicate probes may get a cache hit.
  //
  // Returns: the number of sequential KB read for access to
  // a partition (this includes index and data blocks)
  //
  CostScalar estimateSeqKBReadPerScanMultiProbe() const;

  // Computes the cost vectors (First and Last Row) for this scan.
  // Computes:
  //    - KBytes
  //    - CPU Instructions
  //    - Number of seeks
  //    - Idle time
  //    - number of probes
  // for both cost vectors.
  //
  // OUTPUTS: firstRow and lastRow SimpleCostVectors of the BasicCost
  // object are populated.
  //
  void computeCostVectorsMultiProbes(FileScanBasicCost *basicCostPtr);

  // SimpleFileScanOptimizer::categorizeMultiProbes()
  // Computes and caches the following metrics regarding probes:
  //
  //  probes_ - the total number of probes for all active partitions.
  //
  //  successfulProbes_ - the number of probes (probes_) that produce
  //  some data.
  //
  //  uniqueProbes_ - the number of distinct probes (probes_).  Includes
  //  successful and failed probes.
  //
  //  duplicateSuccProbes_ - the number of successful probes
  //  (successfulProbes_) that are not unique.  duplicateSuccProbes =
  //  successfulProbes - uniqueSuccProbes.
  //
  //  failedProbes_ - the number of probes (probes_) that do not result
  //  in data.  failedProbes = probes - successfulProbes.
  //
  //  dataRows_ - the number of rows produced by all successful probes.
  //  blksPerSuccProbe_ - the estimated number of blocks produced by
  //  each successful probe on average.
  //
  //  inOrderProbesFlag - indicates if the probes arrive in order
  //  relative to the clustering key of the access path.
  //
  // Return Value: void - Computed values are cached in data members.
  //
  void categorizeMultiProbes(NABoolean *isAnIndexJoin=NULL);


  // -----------------------------------------------------------------------
  // This is taken from ScanOptimizer.h
  // The intension is to change categorizaProbes method for SimpleScanOptimizer
  // while keeping the old version for ScanOptimizer, so it couls be used to
  // compare the old and new logic. Th rational for this is to have simpler
  // logic of categorizing probes for SimpleScanOptimizer.
  //
  // Use isMDAM = FALSE when using this in single subset
  // Use isMDAM = TRUE when using this in MDAM. In this case
  //              the routine will assume that we are not in an
  //              index join (it should be the case because
  //              code in the early stages should make sure that
  //              we don't attempt MDAM in an index join). This is
  //              not a correctness issue, it is an efficiency issue.
  // -----------------------------------------------------------------------
  void
  categorizeProbes(CostScalar& successfulProbes /* out */
		   ,CostScalar& uniqueSuccProbes /* out */
		   ,CostScalar& duplicateSuccProbes /* out */
		   ,CostScalar& failedProbes /* out */
		   ,CostScalar& uniqueFailedProbes           
		   ,const CostScalar& probes
		   ,const ValueIdSet& preds
		   ,const Histograms& outerHistograms
                   ,const NABoolean isMDAM
                   ,CostScalar * dataRows = NULL
	           ,NABoolean * isAnIndexJoin=NULL
		   ) const;

  // Estimate the number of different index blocks visited for 
  // MultiProbe Scan. This method will use the number of unique probes
  // and total key length of index columns instead of universal "rule 
  // of thumb" from IndexDesc::getEstimatedIndexBlocksLowerBound()
  void estimateIndexBlockUsageMultiProbeScan();

  // Estimate the real and effective total row count for the table.  The
  // Effective Total Row Count is the size of the bounding subset of
  // all probes.  Typically this will be all the rows of the table,
  // but if all probes are restricted to a subset of rows (e.g. the
  // key predicate contains leading constants) the the effective row
  // count will be less than the total row count.
  //
  // Returns: The estimated real and effective row count.
  //
  void estimateEffTotalRowCount(CostScalar &realRowCount,
                                CostScalar &effRowCount) const;

  // Compute the sequential KBytes accessed to produce the first and
  // last rows. 
  //
  // OUTPUTS: 
  // seqKBFR - The number of KBytes to be accessed to produce the first row.
  // seqKBLR - The number of KBytes to be accessed to produce the last row.
  //
  void estimateKBMultiProbe(CostScalar &seqKBFR, CostScalar &seqKBLR) const;

  // Estimate CPU Instructions (includes Per Request, Per Row and Per KB
  // number of CPU Instructions) for First and Last row accessed.
  //
  // Inputs: 
  //
  //    seeksPerScan - The number of seeks to be performed by this Scan
  //    (single partition).
  //
  //    rowsPerScanFR - The number of rows accessed by this scan before
  //    returning the first row (single partition).
  //
  //    rowsPerScanLR - The number of rows accessed by this scan (single
  //    partition).
  //
  //    seqKBFR - The number of KBytes to be accessed by this Scan to
  //    produce the first row (single partition).
  //
  //    seqKBLR - The number of KBytes to be accessed by this Scan to
  //    produce the last row (single partition).
  //
  // Outputs:
  // cpuInstructionsFR - Number of CPU instructions to access the First row.
  // cpuInstructionsLR - Number of CPU instructions to access the Last row.
  //
  void estimateCPUInstructionsMultiProbe(
                  const CostScalar &seeksPerScan,
                  const CostScalar &rowsPerScanFR,
                  const CostScalar &rowsPerScanLR,
                  const CostScalar &selectedRowsPerScanFR,
                  const CostScalar &selectedRowsPerScanLR,
                  const CostScalar &seqKBFR,
                  const CostScalar &seqKBLR,
                  CostScalar &cpuInstructionsFR,
                  CostScalar &cpuInstructionsLR) const;

  CostScalar getProbeCacheCostAdjFactor() const;
  NABoolean  isProbeCacheApplicable() const;

  // Private Data members -
  // Cache these values from IndexDesc in this class.
  //
  CostScalar recordSizeInKb_;
  CostScalar blockSizeInKb_;
  CostScalar estimatedRecordsPerBlock_;

  // Compute these values during computeSingleSubsetSize()
  //
  // The size of the single subset scanned by this Scan node.
  //
  CostScalar singleSubsetSize_;

  // The key predicates which define the single subset.
  //
  ValueIdSet singleSubsetPreds_;

  // Will be constructed during constructSearchKey() 
  // This search key is not owned by this object and will therefore
  // not be destroyed when the destructor of this object is called.
  // This search key will be returned to the caller
  //
  SearchKey *searchKey_;

  
  // Private inline accessors to local datamembers
  // For Multiprobe scans
  //

  inline const CostScalar getFailedProbes() const     { return failedProbes_; }

  // Return the cached value of number of data rows.  This is the
  // number of rows produced by all successful probes.
  // The value was cached in categorizeMultiProbes().
  // 
  // For MultiProbe Scans
  //
  inline const CostScalar &getDataRows() const            { return dataRows_; }

  // Return the cached value of effective total row count.  This is the
  // size of the bounding subset of all probes.  Typically this will be
  // all the rows of the table, but if all probes are restricted to a
  // subset of rows (e.g. the key predicate contains leading constants)
  // then the effective row count will be less than the total row count.
  // The value was cached in computeCostVectorsMultiProbes().
  //
  //  For MultiProbe Scans
  //
  inline const CostScalar &getEffectiveTotalRowCount() const
                                            { return effectiveTotalRowCount_; }

  // Return the cached value of real total row count.
  // The value was cached in computeCostVectorsMultiProbes().
  //
  //  For MultiProbe Scans
  //
  inline const CostScalar &getTotalRowCount() const { return totalRowCount_; }

  // Return the cached value of the lower bound of the number of index
  // blocks for the table. This value is the estimate of the number of
  // blocks all probes touch in their way down in every level of the
  // B-tree. see IndexDesc::getEstimatedIndexBlocksLowerBound().
  // The value was cached in computeCostVectorsMultiProbes().
  //
  //  For MultiProbe Scans
  //
  inline const CostScalar &getIndexBlocksLowerBound() const
                                            { return indexBlocksLowerBound_; }

  // Return the cached value of number of blocks for each successful
  // probe.  This is the estimated number of blocks produced by each
  // successful probe on average.
  // The value was cached in categorizeMultiProbes().
  // 
  // For MultiProbe Scans
  //
  inline const CostScalar &getBlksPerSuccProbe() const
                                                 { return blksPerSuccProbe_; }

  // Return the value of partialy order probes flag.
  // The value was cached in orderMatch().
  inline const NABoolean  getPartialOrderProbesFlag() const
                                               { return partialOrderProbes_; }

  // This is the number of probes (probes_) that do not result in
  // data.  failedProbes = probes - successfulProbes.  The value is
  // cached in categorizeMultiProbes().
  // 
  // For MultiProbe Scans
  //
  CostScalar failedProbes_;

  // This is the number of rows produced by all successful probes.
  // The value is cached in categorizeMultiProbes().
  // 
  // For MultiProbe Scans
  //
  CostScalar dataRows_;

  // This is the size of the bounding subset of all probes.  Typically
  // this will be all the rows of the table, but if all probes are
  // restricted to a subset of rows (e.g. the key predicate contains
  // leading constants) then the effective row count will be less than
  // the total row count.  The value is cached in
  // computeCostVectorsMultiProbes().
  //
  //  For MultiProbe Scans
  //
  CostScalar effectiveTotalRowCount_;

  // The total row count of the inner table.
  //
  //  For MultiProbe Scans
  //
  CostScalar totalRowCount_;

  // This value is the estimate of the number of blocks all probes
  // touch on their way down in every level of the B-tree. see
  // IndexDesc::getEstimatedIndexBlocksLowerBound().  The value is
  // cached in computeCostVectorsMultiProbes().
  //
  //  For MultiProbe Scans
  //
  CostScalar indexBlocksLowerBound_;

  // This is the estimated number of blocks produced by each
  // successful probe on average.  The value is cached in
  // categorizeMultiProbes().
  // 
  // For MultiProbe Scans
  //
  CostScalar blksPerSuccProbe_;

  // This is total UEC of the key prefix for the Right child.
  CostScalar keyPrefixUEC_;

  // Indicates if the probes are partially in order.
  NABoolean partialOrderProbes_;

}; // class SimpleFileScanOptimizer

#endif