eqlinterpretergenericimpl.java

CRM源码This file describes some issues that should be implemented in future and how it should be imple

            EQLInterpreterGenericImpl _interpreter = ( EQLInterpreterGenericImpl ) clone();
            _interpreter.addEntityInFromList( rightReqEntity, true );
            reqJoin.setReqWhere( _interpreter.getMainMediator().getEQLReq().getWhere() );
        }

        // add right entity in FROM list without CONSTRAINT
        addEntityInFromList( rightReqEntity, false );

        // add  EQLReqJoin in JOIN list
        req.getFrom().addJoinEntity( reqJoin );

        return true;
    }

    /* (non-Javadoc)
     * @see EQLRequestBuilder
     */
    public boolean addWhere( EQLReqField reqField, EQLReqSubWhereCond cond )
        throws EQLException {

        EQLIntMediator mediator = getMainMediator();
        EQLReq req = mediator.getEQLReq();

        if( getLogger().isDebugEnabled() ) {
            DEBUG( "Try to add WHERE" );
            DEBUG( "   field: " + reqField );
            DEBUG( "   right member: " + cond.getRightMember() );
            DEBUG( "   left member: " + cond.getLeftMember() );
        }

        // create new EQLReqSubWhere object
        EQLReqSubWhere reqSubWhere = new EQLReqSubWhere( EQLReqSubWhere.NONE_OP, cond );
        if( req.getWhere().contains( reqSubWhere ) ) {
            return false;
        }

        // add entity in FROM list
        addEntityInFromList( reqField.getReqEntity(), true );

        // add EQLReqSubWhere in WHERE list
        req.getWhere().addSubWhere( reqSubWhere );

        return true;
    }

    // ------------------------------------------------------- private methods

    /**
     * Attempt to find suited dataschemas for given entity and
     * other entities using <code>Chain</code> objects
     * @param rightReqEntity right (slave) entity structure
     * @param leftField indicates field we need to add join (optional)
     * @throws EQLException if can't join entities
     */
    private void addChainTab( EQLReqEntity rightReqEntity, EQLReqField leftField )
        throws EQLException {

        // list of already added entities
        EQLReq req = getMainMediator().getEQLReq();
        ArrayList entityFromList = req.getFrom().getFromEntities();
        int count = entityFromList.size();

        // empty list
        boolean find = false;
        if( count == 0 ) {
            find = true;
        }

        // main cycle
        int i = 0;
        while( !find && i < count ) {
            EQLReqEntity leftReqEntity = ( EQLReqEntity ) entityFromList.get( i++ );

            if( getLogger().isDebugEnabled() ) {
                DEBUG( "Try to chain left entity [" + leftReqEntity + "] and right entity [" + rightReqEntity + "]" );

            }
            find = addChainTab( leftReqEntity, rightReqEntity, leftField );
        }

        if( !find ) {
            throw new EQLException( "Can't join entity '" + rightReqEntity.getEntity().getName() +
                                    "' with:\n" + entityFromList );
        }
    }

    /**
     * Add Dataschema objects in list from ChainTable
     * @param leftReqEntity left (master) entity structure
     * @param rightReqEntity right (slave) entity structure
     * @param leftReqField for what field we're adding chain (optional)
     * @return true if added
     * @throws EQLException
     */
    private boolean addChainTab( EQLReqEntity leftReqEntity,
                                 EQLReqEntity rightReqEntity,
                                 EQLReqField leftReqField )
        throws EQLException {

        Entity leftEntity = leftReqEntity.getEntity();
        Entity rightEntity = rightReqEntity.getEntity();
        if( leftReqEntity.equals( rightReqEntity ) ) {
            return true;
        }

        String leftEntityName = leftEntity.getName();
        String rightEntityName = rightEntity.getName();

        ChainTable ctab = EntityHelper.getChainTable( rightEntityName, leftEntity );
        if( ctab == null ) {
            WARN( "There are no any chains between entity '" + leftEntityName + "' and entity '" + rightEntityName + "'" );
            return false;
        }

        Chainref chainRef = ctab.getChainref();
        Dataschema ds = ctab.getDataschema();

        if( chainRef != null ) {
            // we have another chain
            String chainEntityName = chainRef.getEntity();
            Entity chainEntity = session.findEntity( chainEntityName );
            EQLReqEntity chainReqEntity = new EQLReqEntity( chainEntity );

            if( getLogger().isDebugEnabled() ) {
                DEBUG( "Find external chain using chain entity: " + chainEntityName );
            }

            // find new chain between e1 and chain entity
            boolean ret1 = addChainTab( leftReqEntity, chainReqEntity, leftReqField );
            if( getLogger().isDebugEnabled() ) {
                DEBUG( "   1 between '" + leftEntityName + "' and '" + chainEntityName + "' ret=" + ret1 );
            }
            if( !ret1 ) {
                return false;
            }

            // find new chain between chain entity and e2
            boolean ret2 = addChainTab( chainReqEntity, rightReqEntity, leftReqField );
            if( getLogger().isDebugEnabled() ) {
                DEBUG( "   2 between '" + chainEntityName + "' and '" + rightEntityName + "' ret=" + ret2 );
            }
            if( !ret2 ) {
                return false;
            }

        } else if( ds != null ) {
            // add Dataschema object
            addDataschema( leftReqEntity, rightReqEntity, ds, leftReqField );

        } else {
            // add right entity in FROM list only
            addEntityInFromList( rightReqEntity, true );
        }

        return true;
    }

    //
    // Add dataschema
    //
    private void addDataschema( EQLReqEntity reqEntity1,
                                EQLReqEntity reqEntity2,
                                Dataschema ds,
                                EQLReqField leftReqField )
        throws EQLException {

        String entityName1 = reqEntity1.getEntity().getName();
        String entityName2 = reqEntity2.getEntity().getName();
        String[] keys1 = ds.getTable( 0 ).getKey();
        String[] keys2 = ds.getTable( 1 ).getKey();
        int keySize = keys1.length;

        ArrayList reqFields1 = new ArrayList( keySize );
        ArrayList reqFields2 = new ArrayList( keySize );

        for( int i = 0; i < keySize; i++ ) {
            Efield efield1 = EntityHelper.getEfieldBySrc( keys1[i], reqEntity1.getEntity() );
            Efield efield2 = EntityHelper.getEfieldBySrc( keys2[i], reqEntity2.getEntity() );

            reqFields1.add( new EQLReqField( reqEntity1, efield1 ) );
            reqFields2.add( new EQLReqField( reqEntity2, efield2 ) );
        }

        if( getLogger().isDebugEnabled() ) {
            DEBUG( "Try to add dataschema:" );
            DEBUG( "   name: " + ds.getName() );
            DEBUG( "   ref type=" + ds.getReftype() );
            DEBUG( "   left entity=" + entityName1 );
            DEBUG( "   right entity=" + entityName2 );
        }

        // check if dataset reference type = '1:n'
        if( ds.getReftype().getType() == RefSType.VALUE_1_TYPE ) {
            // add DISTINCT
            getMainMediator().getEQLReq().getSelect().setIsDistinct( true );
        }

        // add JOIN clause
        addJoin( reqFields1, reqFields2, leftReqField );
    }

    //
    // Add entity in EQL from list
    //
    private void addEntityInFromList( EQLReqEntity reqEntity, boolean addConstraint )
        throws EQLException {

        EQLIntMediator mediator = getMainMediator();

        EQLReq req = mediator.getEQLReq();
        if( req.getFrom().contains( reqEntity ) ) {
            return;
        }

        if( isClonned ) {
            // for clonned EQL interpreter check reqEntity in parent EQLReq object
            // if found -- don't add
            // [!!!] check only one nested level
            if( parentMediator.getEQLReq().getFrom().contains( reqEntity ) ) {
                if( getLogger().isDebugEnabled() ) {
                    DEBUG( "Entity '" + reqEntity + "' found in parent mediator. Skip..." );
                }
                return;
            }
        }

        // add entity
        req.getFrom().addFromEntity( reqEntity );

        if( addConstraint ) {
            // add entity CONSTRAINT
            String eqlConstraintQuery = reqEntity.getEntity().getEqlConstraint();
            if( eqlConstraintQuery != null ) {
                mediator.parseWhere( eqlConstraintQuery );
            }
        }
    }
}