eqlintmediator.java

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

     * @param reqWhere parent where object
     * @param where_op where operation id
     * @param subWhereCond EQLReqSubWhereCond sub where condition
     * @throws EQLException
     */
    public void addSubWhereCondition( EQLReqWhere reqWhere,
                                      int where_op,
                                      EQLReqSubWhereCond subWhereCond )
        throws EQLException {

        if( getLogger().isDebugEnabled() ) {
            DEBUG( " addSubWhereCondition(): " + where_op );
        }

        // add sub where condition
        EQLReqSubWhere reqSubWhere = new EQLReqSubWhere( where_op, subWhereCond );
        if( !reqWhere.contains( reqSubWhere ) ) {
            reqWhere.addSubWhere( reqSubWhere );
        }
    }

    /**
     * Create and add new where as subwhere object
     * @param reqWhere parent where object
     * @param where_op where operation id
     * @return new child where object
     * @throws EQLException
     */
    public EQLReqWhere addSubWhere( EQLReqWhere reqWhere, int where_op )
        throws EQLException {

        if( getLogger().isDebugEnabled() ) {
            DEBUG( " addSubWhere(): " + where_op );
        }

        // create new EQL req where
        EQLReqWhere newReqWhere = new EQLReqWhere();

        // add sub where condition
        EQLReqSubWhere reqSubWhere = new EQLReqSubWhere( where_op, newReqWhere );
        if( !reqWhere.contains( reqSubWhere ) ) {
            reqWhere.addSubWhere( reqSubWhere );
        }

        return newReqWhere;
    }

    /**
     * Create and add new where as subwhere object
     * @param reqField EQLReqField object
     * @param order_op order operation id
     * @param mandatory mandatory order or not
     * @throws EQLException
     */
    public void addSubOrder( EQLReqField reqField, int order_op, boolean mandatory )
        throws EQLException {

        if( getLogger().isDebugEnabled() ) {
            DEBUG( " addSubOrder(): " + order_op );
        }

        if( reqField.getField().getListref() != null ) {
            // add list reference
            reqField = interpreter.addListField( reqField );
        } else {
            // add field
            reqField = interpreter.addField( reqField );
        }

        // create bew req operation
        EQLReqOp reqOp = buildSelectEQLReqOp( reqField );

        // create and add new sub order
        EQLReqSubOrder subOrder = new EQLReqSubOrder( order_op, reqOp, mandatory );
        getEQLReq().getOrder().addSubOrder( subOrder );
    }

    /**
     * Add sub operation in operation object
     * @param reqSubOp sub operation object object
     * @param reqOp operation object
     * @throws EQLException
     */
    public void addSubOp( EQLReqSubOp reqSubOp, EQLReqOp reqOp )
        throws EQLException {

        if( getLogger().isDebugEnabled() ) {
            DEBUG( " addSubOp() " + reqSubOp.getClass() );
        }

        // add sub operation
        reqOp.addSubOp( reqSubOp );
    }

    /**
     * Try to get EQLReqSubOpMember object from EQL prepared statement
     * @return EQLReqSubOpMember object or build new
     * @throws EQLException
     */
    public EQLReqSubOpMember buildNextSubOperation()
        throws EQLException {

        if( getLogger().isDebugEnabled() ) {
            DEBUG( " nextSubOperation()" );
        }

        EQLReqSubOpMember o = null;
        if( interpreter.getPreparedStatement() != null ) {
            // get sub operation member from EQL prepared statement
            o = interpreter.getPreparedStatement().next();
        }

        return( o == null ) ? new EQLReqSubOpMemberUnknown() : o;
    }

    /**
     * Build new sub operation member
     * @param value number
     * @return EQLObject object
     * @throws EQLException
     */
    public EQLObject buildSubOperationMemberNumber( String value )
        throws EQLException {

        if( getLogger().isDebugEnabled() ) {
            DEBUG( " buildSubOperationMemberNumber(): " + value );
        }

        // build sub operation member number
        Number number = EQLUtils.parseEQLNumber( value );
        return new EQLNumberObject( number );
    }

    /**
     * Build new sub operation member
     * @param value string
     * @return EQLObject object
     * @throws EQLException
     */
    public EQLObject buildSubOperationMemberString( String value )
        throws EQLException {

        if( getLogger().isDebugEnabled() ) {
            DEBUG( " buildSubOperationMemberString(): " + value );
        }

        // build sub operation member string
        return new EQLStringObject( value );
    }

    /**
     * Build new sub operation member
     * @return EQLObject object
     * @throws EQLException
     */
    public EQLObject buildSubOperationMemberNull()
        throws EQLException {

        if( getLogger().isDebugEnabled() ) {
            DEBUG( " buildSubOperationMemberNull()" );
        }

        // build sub operation member null
        return EQLNullObject.getInstance();
    }

    /**
     * Build new sub operation member
     * @param reqField req field object
     * @return EQLReqSubOpMember object
     * @throws EQLException
     */
    public EQLReqSubOpMember buildSubOperationMemberField( EQLReqField reqField )
        throws EQLException {

        if( getLogger().isDebugEnabled() ) {
            DEBUG( " buildSubOperationMemberField(): " + reqField );
        }

        /** @todo check for virtual field */

        // add field
        reqField = interpreter.addField( reqField );

        // build sub operation member field
        return new EQLReqSubOpMemberField( reqField );
    }

    /**
     * Build new sub operation member
     * @param reqField EQLReqField object
     * @return EQLReqSubOpMember object
     * @throws EQLException
     */
    public EQLReqSubOpMember buildSubOperationMemberListField( EQLReqField reqField )
        throws EQLException {

        if( getLogger().isDebugEnabled() ) {
            DEBUG( " buildSubOperationMemberListField(): " + reqField );
        }

        /** @todo check for virtual field */

        // add list field
        EQLReqField listReqField = interpreter.addListField( reqField );

        return buildSelectEQLReqOp( listReqField );
    }

    /**
     * Build new sub operation member
     * @param func EQLReqSubOpMemberFunc object
     * @return EQLReqSubOpMember object
     * @throws EQLException
     */
    public EQLReqSubOpMember buildSubOperationMemberFunc( EQLReqSubOpMemberFunc func )
        throws EQLException {

        if( getLogger().isDebugEnabled() ) {
            DEBUG( " buildSubOperationMemberFunc(): " + func );
        }

        if( func instanceof EQLReqFuncExecutable ) {
            // execute function
            return( ( EQLReqFuncExecutable ) func ).execute();
        } else {
            return func;
        }
    }

    /**
     * Add new function parameter
     * @param func EQL function
     * @param funcParam function parameter
     * @throws EQLException
     */
    public void addFunctionParameter( EQLReqSubOpMemberFunc func, EQLReqOp funcParam )
        throws EQLException {

        if( getLogger().isDebugEnabled() ) {
            DEBUG( " addFunctionParameter(): " + func + "," + funcParam );
        }

        func.addParameter( funcParam );

        // register field in EQL interpreter
        int size = funcParam.size();
        for( int i = 0; i < size; i++ ) {
            EQLReqSubOp subOp = funcParam.getSubOp( i );
            EQLReqSubOpMember subOpMember = subOp.getMember();

            if( subOpMember instanceof EQLReqSubOpMemberField ) {
                EQLReqSubOpMemberField memberField = ( EQLReqSubOpMemberField ) subOpMember;
                EQLReqField reqField = memberField.getReqField();

                // add entity and entity constraint
                // and get new req field
                reqField = interpreter.addField( reqField );

                if( func instanceof EQLReqAggFunc ) {
                    // for aggregate function add entity WHERE condition
                    addEntityWhereCondition( reqField.getReqEntity() );
                }

                // substitute member field
                subOp.setMember( new EQLReqSubOpMemberField( reqField ) );
            }
        }
    }

    /**
     * Add new enumeration parameter
     * @param en EQL enumeration
     * @param enumParam enumeration parameter
     * @throws EQLException
     */
    public void addEnumParameter( EQLReqSubOpMemberEnum en, EQLObject enumParam )
        throws EQLException {

        if( getLogger().isDebugEnabled() ) {
            DEBUG( " addEnumParameter(): " + en + "," + enumParam );
        }

        // currently supportes only primitive types in enumeration
        /** @todo make support of other EQL types */

        en.addParameter( enumParam );
    }

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

    /**
     * Add list reference default value
     * @param reqSelectAttr parent EQLReqSelectAttr object
     * @param reqField EQLReqField object
     * @throws EQLException
     */
    private void addListFieldAsDefault( EQLReqSelectAttr reqSelectAttr,
                                        EQLReqField reqField )
        throws EQLException {

        Entity entity = reqField.getReqEntity().getEntity();
        Listref listRef = reqField.getField().getListref();
        if( listRef == null ) {
            return;
        }

        // get listref entity and field
        Entity lrefEntity = interpreter.getSession().findEntity( listRef.getEntity() );
        Efield lrefField = EntityHelper.getEfield( listRef.getEfield(), lrefEntity );

        // construct list ref EQLReqEntity and EQLReqField objects
        EQLReqEntity lrefReqEntity = new EQLReqEntity( lrefEntity, reqField );
        EQLReqField listReqField = new EQLReqField( lrefReqEntity, lrefField );

        //
        // Left operation doesn't contain field.
        // So we can't add JOIN - add WHERE clause instead!
        //
        Dataschema ds = listRef.getDataschema();
        String[] keys1 = ds.getTable( 0 ).getKey();
        String[] keys2 = ds.getTable( 1 ).getKey();
        int keySize = keys1.length;

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

            EQLReqField reqField1 = new EQLReqField( entity, efield1 );
            EQLReqField reqField2 = new EQLReqField( lrefEntity, efield2 );

            EQLReqOp reqOp = buildDefaultSelectEQLReqOp( reqField1 );
            EqCond cond = new EqCond( reqOp, new EQLReqOp( reqField2 ) );
            interpreter.addWhere( reqField2, cond );
        }

        if( getLogger().isDebugEnabled() ) {
            DEBUG( "Add def list field: " + listReqField );
        }

        // build list reference EQLReqSelectAttr object
        reqSelectAttr.setListFieldSelectAttr(
            new EQLReqSelectAttr( listReqField, buildSelectEQLReqOp( listReqField ) )
            );
    }

    /**
     * Build EQLReqOp object for select attribute
     * Takes <code>eql-src</code> Efield attribute if exists
     * @param reqField EQLReqField object
     * @return EQLReqOp object
     * @throws EQLException
     */
    private EQLReqOp buildSelectEQLReqOp( EQLReqField reqField )
        throws EQLException {

        Efield field = reqField.getField();

        // check: has field 'eql-src' attribute
        EQLReqOp reqOp;
        if( field.getEqlSrc() != null ) {
            reqOp = parseSrc( field.getEqlSrc() );
        } else {
            reqOp = new EQLReqOp( reqField );
        }

        return reqOp;
    }

    /**
     * Build EQLReqOp object for select attribute
     * Takes <code>eql-defsrc</code> Efield attribute
     * @param reqField EQLReqField object
     * @return EQLReqOp object
     * @throws EQLException
     */
    private EQLReqOp buildDefaultSelectEQLReqOp( EQLReqField reqField )
        throws EQLException {

        Efield field = reqField.getField();
        String eqlDefSrc = field.getEqlDefsrc();

        // check: has field 'eql-defsrc' attribute
        EQLReqOp reqOp = null;
        if( eqlDefSrc != null ) {
            reqOp = parseSrc( eqlDefSrc );
        } else {
            reqOp = new EQLReqOp();
            reqOp.addSubOp( new NoneOp( EQLNullObject.getInstance() ) );
        }

        return reqOp;
    }
}