sqlexecutorgenericimpl.java

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

        return record;
    }

    //
    // Read dataset <code>dReq</code> for given record <code>resRecord</code>
    //
    protected EQLDRes getDatasetData( Connection con,
                                      EQLDReq dReq,
                                      EQLSql datasetEqlSql,
                                      EQLResRecord resRecord )
        throws EQLException {

        // Init.
        EQLDRes dRes = null;
        String datasetSql = datasetEqlSql.getMainSql();
        EQLObject[] datasetSqlParams = datasetEqlSql.getSqlParameters();
        int params = ( datasetSqlParams == null ) ? 0 : datasetSqlParams.length;

        // Get DatasetKeys object for given dataset.
        DatasetKeys dk = getDatasetKeys( dReq );

        PreparedStatement ps = null;
        try {

            // make sql statement
            ps = getStatement( con, datasetSql, datasetSqlParams );

            // build dataset EQL response object
            dRes = ( EQLDRes ) newEQLRes( dReq, datasetEqlSql );

            // set foreign keys
            String[] fKeyNames = dk.getFKeyNames();
            EQLReqField[] fkReqFields = dk.getFKeyReqFields();
            for( int k = 0; k < fKeyNames.length; k++ ) {
                EQLResCell resCell = resRecord.getResCell( fkReqFields[k] );
                ps.setObject( params + 1 + k, resCell.getEQLObject().getObject() );
            }

            // execute query
            ResultSet rs = sqlWrapper.executeQuery( ps );

            // result set cursor
            ResultSetCursor cursor = new ResultSetCursor( rs );

            // get data
            while( rs.next() ) {
                EQLResRecord record = getRecord( cursor, dReq );
                dRes.addRecord( record );

                // reset cursor
                cursor.reset();
            }

        } catch( SQLException ex ) {
            throw new EQLSystemException( ex );

        } finally {
            sqlWrapper.closeConnection( ps );
        }

        // Ok.
        return dRes;
    }

    //
    // Read one field (with listfield)
    //
    protected EQLResCell getField( EQLReq req,
                                   EQLReqSelectAttr reqSelectAttr,
                                   ResultSetCursor cursor )
        throws EQLException {

        EQLReqField reqField = reqSelectAttr.getReqField();
        boolean isLazy = req.isLazy( reqField.getField() );
        
        EQLResCell resCell;
        if( reqSelectAttr.isConstant() ) {
            EQLObject constObj = reqSelectAttr.getConstant();
            // filed value is constant
            resCell = new EQLResCell( reqField, constObj );
            cursor.next();
        } else {
            
            if( isLazy ) {
                // field for lazy loading
                resCell = getLazyCell( req, reqField, cursor );
                
            } else {
                
                // retrive field value
                resCell = getCell( req, reqField, cursor );
                
                // retrive listfield value
                Listref listref = reqField.getField().getListref();
                if( listref != null ) {
                    EQLReqSelectAttr listReqSelectAttr = reqSelectAttr.getListFieldSelectAttr();
                    EQLResCell listResCell = getListFieldValue(
                        req,
                        reqField,
                        listReqSelectAttr,
                        resCell.getEQLObject().getObject(),
                        cursor );
                    
                    resCell.addListField( listResCell );
                }
                
            }
        }
        
        return resCell;
    }

    //
    // Read list field result cell
    //
    protected EQLResCell getListFieldValue( EQLReq req,
                                            EQLReqField masterReqField,
                                            EQLReqSelectAttr listReqSelectAttr,
                                            Object pkey,
                                            ResultSetCursor cursor )
        throws EQLException {

        Listref listref = masterReqField.getField().getListref();
        EQLResCell listResCell = null;

        // check list field JOIN type
        JoinSType joinType = listref.getJointype();
        switch( joinType.getType() ) {

        case JoinSType.USE_CACHE_TYPE:

            // take value from cache
            if( pkey != null ) {
                EQLReqField listReqField = getListReqField( masterReqField.getField(), listref );
                Entity lrefEntity = listReqField.getReqEntity().getEntity();
                Efield lrefField = listReqField.getField();
                listResCell = getCachedCell( lrefEntity, lrefField, pkey );
            }
            break;

        default:

            // default procedure
            if( listReqSelectAttr != null ) {
                EQLReqField listReqField = listReqSelectAttr.getReqField();
                listResCell = getCell( req, listReqField, cursor );
            }
        }

        return listResCell;
    }

    //
    // Read one column
    //
    protected EQLResCell getCell( EQLReq req,
                                  EQLReqField reqField,
                                  ResultSetCursor cursor )
        throws EQLException {

        Efield field = reqField.getField();
        int sqlType = field.getSqltype().getType();

        try {
            Object o = sqlWrapper.getParser( sqlType ).
                getObject( cursor.rs(), cursor.next() );
            return new EQLResCell( reqField, EQLObject.getInstance( o ) );

        } catch( SQLException ex ) {
            ERROR( "Can't get cell for field '" + reqField.getField().getId() +
                   "' with type '" + field.getSqltype() + "'. Pos: " + cursor.current(), ex );
            throw new EQLSystemException( ex );
        }
    }

    //
    // Lazy read one column
    //
    protected EQLResCell getLazyCell( EQLReq req,
                                      EQLReqField reqField,
                                      ResultSetCursor cursor )
        throws EQLException {

        Efield field = reqField.getField();
        int sqlType = field.getSqltype().getType();

        try {
            Object o = sqlWrapper.getParser( sqlType ).
                getObject( cursor.rs(), cursor.next() );
            return new EQLResCell( reqField, ( o == null ) );

        } catch( SQLException ex ) {
            throw new EQLSystemException( ex );
        }
    }

    //
    // Build SQL Connection object
    //
    protected Connection getConnection() {
        // return XA connection
        return sqlWrapper.doConnection();
    }

    //
    // Build SQL PreparedStatement object
    //
    protected PreparedStatement getStatement( Connection con,
                                              String sql,
                                              EQLObject[] sqlParams )
        throws EQLException {

        PreparedStatement ps = sqlWrapper.doPreparedStatement( con, sql );
        if( sqlParams != null ) {
            for( int i = 0; i < sqlParams.length; i++ ) {
                EQLObject param = sqlParams[i];

                if( getLogger().isDebugEnabled() ) {
                    // Cut long string.
                    DEBUG( "Set parameter '" + param.toShortString() + "' in position #" + i +
                           " of statement" );
                }

                try {
                    sqlWrapper.getParser( param.getSqlType() ).
                        setObject( ps, i + 1, param.getObject() );

                } catch( SQLException ex ) {
                    throw new EQLSystemException( ex );
                }
            }
        }

        return ps;
    }

    //
    // Get DatasetKeys object for <code>datasetReq</code>.
    //
    protected DatasetKeys getDatasetKeys( EQLDReq dReq ) {

        String key = dReq.getReqDataset().getDataset().getId();
        DatasetKeys dk = ( DatasetKeys ) datasetKeysMap.get( key );
        if( dk == null ) {
            DEBUG( "Create new DatasetKeys object for: " + key );
            dk = new DatasetKeys( getSession(), dReq );
            datasetKeysMap.put( key, dk );
        }

        return dk;
    }

    //
    // Get EQLReqField for list field
    //
    protected EQLReqField getListReqField( Efield masterField, Listref listref ) {

        String key = masterField.getId();
        EQLReqField reqField = ( EQLReqField ) listReqFieldMap.get( key );
        if( reqField == null ) {
            DEBUG( "Create new EQLReqField object for: " + key );
            Entity lrefEntity = getSession().findEntity( listref.getEntity() );
            Efield lrefField = EntityHelper.getEfield( listref.getEfield(), lrefEntity );
            reqField = new EQLReqField( lrefEntity, lrefField );
            listReqFieldMap.put( key, reqField );
        }

        return reqField;
    }

    //
    // Get cached cell
    //
    protected EQLResCell getCachedCell( Entity entity, Efield field, Object pkey )
        throws EQLException {

        LogonSession ls = getSession().getLogonSession();
        EQLManagerLocal local = ( EQLManagerLocal ) getSession().getCOM().
            getLocalObject( JNDINames.EQLManager, EQLManagerLocalHome.class );

        return EQLUtils.getCachedCell( entity, field, pkey, ls, local );
    }

    // ----------------------------------------------------- INNER CLASSES

    /**
     * <p>Class - result set cursor</p>
     * @author [ALB] Baranov Andrey
     * @version $Revision: 1.2 $ $Date: 2006/01/20 15:19:10 $
     */

    public static class ResultSetCursor {

        private ResultSet rs;
        private int pos = 1;

        public ResultSetCursor( ResultSet rs ) {
            this.rs = rs;
        }

        public ResultSet rs() {
            return rs;
        }

        public int current() {
            return pos;
        }

        public int next() {
            return pos++;
        }

        public void reset() {
            pos = 1;
        }

    } //-- end inner class


    /**
     * <p>Class - special class to store dataset keys</p>
     * @author [ALB] Baranov Andrey
     * @version $Revision: 1.2 $ $Date: 2006/01/20 15:19:10 $
     */

    public static class DatasetKeys {

        private Dataset baseDataset;
        private String[] fKeys;
        private EQLReqField[] fkReqFields;

        // Constructor: build array of EQLReqField foreign keys
        public DatasetKeys( EQLSession session, EQLDReq dReq ) {

            baseDataset = dReq.getReqDataset().getDataset();
            Entity baseEntity = session.findEntity( baseDataset.getEntityName() );

            fKeys = baseDataset.getDataschema().getTable( 0 ).getKey();
            fkReqFields = new EQLReqField[fKeys.length];
            for( int k = 0; k < fKeys.length; k++ ) {
                Efield fkField = EntityHelper.getEfieldBySrc( fKeys[k], baseEntity );
                fkReqFields[k] = new EQLReqField( baseEntity, fkField );
            }
        }

        public String[] getFKeyNames() {
            return fKeys;
        }

        public EQLReqField[] getFKeyReqFields() {
            return fkReqFields;
        }

        public int hashCode() {
            return baseDataset.getId().hashCode();
        }

        public boolean equals( Object o ) {
            if( o == null || ! ( o instanceof DatasetKeys ) ) {
                return false;
            }

            DatasetKeys dk = ( DatasetKeys ) o;
            return dk.baseDataset.getId().equals( baseDataset.getId() );
        }

    } //-- end inner class
}