LhxJoinExecStream.h

Go to the documentation of this file.

/*
// $Id: //open/dev/fennel/hashexe/LhxJoinExecStream.h#2 $
// Fennel is a library of data storage and processing components.
// Copyright (C) 2006-2009 The Eigenbase Project
// Copyright (C) 2009-2009 SQLstream, Inc.
// Copyright (C) 2006-2009 LucidEra, Inc.
//
// This program is free software; you can redistribute it and/or modify it
// under the terms of the GNU General Public License as published by the Free
// Software Foundation; either version 2 of the License, or (at your option)
// any later version approved by The Eigenbase Project.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#ifndef Fennel_LhxJoinExecStream_Included
#define Fennel_LhxJoinExecStream_Included

#include "fennel/exec/ConfluenceExecStream.h"
#include "fennel/hashexe/LhxHashBase.h"
#include "fennel/hashexe/LhxHashTable.h"
#include "fennel/hashexe/LhxPartition.h"

using namespace boost;

FENNEL_BEGIN_NAMESPACE

struct LhxJoinExecStreamParams : public ConfluenceExecStreamParams
{
    SharedSegment pTempSegment;

    bool enableSubPartStat;

    uint forcePartitionLevel;

    // REVIEW jvs 25-Aug-2006: See my comments on LhxAggExecStreamParams
    // regarding these fields (w.r.t. comment cross-refs).

    RecordNum cndKeys;

    RecordNum numRows;

    bool leftInner;

    bool leftOuter;

    bool rightInner;

    bool rightOuter;

    TupleProjection leftKeyProj;

    TupleProjection rightKeyProj;

    TupleProjection filterNullKeyProj;

    TupleProjection outputProj;

    bool setopDistinct;
    bool setopAll;

    bool enableJoinFilter;

    bool enableSwing;
};

class FENNEL_HASHEXE_EXPORT LhxJoinExecStream
    : public ConfluenceExecStream
{
    // REVIEW jvs 26-Aug-2006:  Fennel convention for enum names is
    // all uppercase with underscores

    enum LhxDefaultJoinInputIndex {
        DefaultProbeInputIndex = 0, DefaultBuildInputIndex = 1
    };

    enum LhxJoinState {
        ForcePartitionBuild, Build, Probe,
        ProduceBuild, ProducePending,
        Partition, CreateChildPlan, GetNextPlan, Done
    };

    shared_array<TupleData> inputTuple;
    shared_array<uint> inputTupleSize;

    TupleData outputTuple;

    uint numTuplesProduced;

    LhxHashInfo hashInfo;

    LhxHashTable hashTable;
    LhxHashTableReader hashTableReader;

    BlockNum numBlocksHashTable;

    uint numMiscCacheBlocks;

    /*
     * Plan
     */
    bool isTopPlan;
    SharedLhxPlan rootPlan;
    LhxPlan *curPlan;

    LhxPartitionInfo partInfo;

    SharedLhxPartition buildPart;
    SharedLhxPartition probePart;

    LhxPartitionReader buildReader;
    LhxPartitionReader probeReader;

    bool enableSubPartStat;

    bool enableSwing;

    uint forcePartitionLevel;

    /*
     * State of the JoinExecStream
     */
    LhxJoinState joinState;

    vector<LhxJoinState> nextState;

    /*
     * Join semantics
     */
    shared_ptr<dynamic_bitset<> > joinType;

    bool regularJoin;
    bool setopDistinct;
    bool setopAll;

    virtual void closeImpl();

    /*
     * Decide the join and setop semantics from exec stream parameters.
     */
    void setJoinType(LhxJoinExecStreamParams const &params);

    /*
     * Set up hashInfo from exec stream parameters.
     */
    void setHashInfo(LhxJoinExecStreamParams const &params);

    /*
     * Plan returns matched tuples from the probe side.
     * If curPlan is NULL, uses the default probe side where inputIndex == 0.
     */
    inline bool returnProbeInner(LhxPlan *curPlan = NULL);

    /*
     * Plan returns matched tuples from the build side.
     */
    inline bool returnBuildInner(LhxPlan *curPlan = NULL);

    /*
     * Plan returns non-matched tuples from the probe side.
     */
    inline bool returnProbeOuter(LhxPlan *curPlan = NULL);

    /*
     * Plan returns non-matched tuples from the build side.
     */
    inline bool returnBuildOuter(LhxPlan *curPlan = NULL);

    /*
     * Plan returns matched tuples from both join sides.
     */
    inline bool returnInner(LhxPlan *curPlan = NULL);

    /*
     * Plan returns tuples, matched or non-matched, from the probe side.
     */
    inline bool returnProbe(LhxPlan *curPlan = NULL);

    /*
     * Plan returns tuples, matched or non-matched, from the build side.
     */
    inline bool returnBuild(LhxPlan *curPlan = NULL);

public:
    /*
     * implement ExecStream
     */
    virtual void prepare(LhxJoinExecStreamParams const &params);

    virtual void open(bool restart);

    virtual ExecStreamResult execute(ExecStreamQuantum const &quantum);

    virtual void getResourceRequirements(
        ExecStreamResourceQuantity &minQuantity,
        ExecStreamResourceQuantity &optQuantity,
        ExecStreamResourceSettingType &optType);

    virtual void setResourceAllocation(
        ExecStreamResourceQuantity &quantity);
};

inline bool LhxJoinExecStream::returnProbeInner(LhxPlan *curPlan)
{
    uint probeInput = (curPlan == NULL) ? 0 : curPlan->getProbeInput();
    return joinType->test(probeInput * 2 + 0);
}

inline bool LhxJoinExecStream::returnBuildInner(LhxPlan *curPlan)
{
    uint buildInput = (curPlan == NULL) ? 1 : curPlan->getBuildInput();
    return joinType->test(buildInput * 2 + 0);
}

inline bool LhxJoinExecStream::returnProbeOuter(LhxPlan *curPlan)
{
    uint probeInput = (curPlan == NULL) ? 0 : curPlan->getProbeInput();
    return joinType->test(probeInput * 2 + 1);
}

inline bool LhxJoinExecStream::returnBuildOuter(LhxPlan *curPlan)
{
    uint buildInput = (curPlan == NULL) ? 1 : curPlan->getBuildInput();
    return joinType->test(buildInput * 2 + 1);
}

inline bool LhxJoinExecStream::returnInner(LhxPlan *curPlan)
{
    return (returnProbeInner(curPlan) && returnBuildInner(curPlan));
}

inline bool LhxJoinExecStream::returnProbe(LhxPlan *curPlan)
{
    return (returnProbeInner(curPlan) || returnProbeOuter(curPlan));
}

inline bool LhxJoinExecStream::returnBuild(LhxPlan *curPlan)
{
    return (returnBuildInner(curPlan) || returnBuildOuter(curPlan));
}

FENNEL_END_NAMESPACE

#endif

// End LhxJoinExecStream.h

---