* JBoss, Home of Professional Open Source.

* Copyright 2008, Red Hat Middleware LLC, and individual contributors

* as indicated by the @author tags. See the copyright.txt file in the

* distribution for a full listing of individual contributors.

*

* This is free software; you can redistribute it and/or modify it

* under the terms of the GNU Lesser General Public License as

* published by the Free Software Foundation; either version 2.1 of

* the License, or (at your option) any later version.

*

* This software 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

* Lesser General Public License for more details.

*

* You should have received a copy of the GNU Lesser General Public

* License along with this software; if not, write to the Free

* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA

* 02110-1301 USA, or see the FSF site: http://www.fsf.org.

*/

* Compiles EJB-QL and JBossQL into SQL.

*

* @author <a href="mailto:dain@daingroup.com">Dain Sundstrom</a>

* @author <a href="mailto:alex@jboss.org">Alex Loubyansky</a>

* @version $Revision: 102957 $

*/

   // input objects

   private final Catalog catalog;

   private Class returnType;

   private Class[] parameterTypes;

   private JDBCReadAheadMetaData readAhead;

   private boolean lazyResultSetLoading;

   // alias info

   private AliasManager aliasManager;

   // join info

   private Set declaredPaths = new HashSet();

   private Set ctermJoinPaths = new HashSet();

   private Set allJoinPaths = new HashSet();

   private Map ctermCollectionMemberJoinPaths = new HashMap();

   private Map allCollectionMemberJoinPaths = new HashMap();

   private Map ctermLeftJoinPaths = new HashMap();

   private Map allLeftJoinPaths = new HashMap();

   // mapping metadata

   private JDBCTypeMappingMetaData typeMapping;

   private JDBCTypeFactory typeFactory;

   private boolean subquerySupported;

   // output objects

   private boolean forceDistinct;

   private String sql;

   private int offsetParam;

   private int offsetValue;

   private int limitParam;

   private int limitValue;

   private JDBCStoreManager selectManager;

   private Object selectObject;

   private List inputParameters = new ArrayList();

   private JDBCType functionJDBCType;

   /**

    * deep read ahead for cmrs

    */

   private List leftJoinCMRList = new ArrayList();

   private StringBuffer onFindCMRJoin;

   private boolean countCompositePk;

   private String selectAlias;

   private boolean selectDistinct;

   public JDBCEJBQLCompiler(Catalog catalog)

   {

      this.catalog = catalog;

   }

   public void compileEJBQL(String ejbql,

                            Class returnType,

                            Class[] parameterTypes,

                            JDBCQueryMetaData metadata) throws Exception

   {

      // reset all state variables

      reset();

      // set input arguemts

      this.returnType = returnType;

      this.parameterTypes = parameterTypes;

      this.readAhead = metadata.getReadAhead();

      this.lazyResultSetLoading = metadata.isLazyResultSetLoading();

      // get the parser

      EJBQLParser parser = new EJBQLParser(new StringReader(SQLUtil.EMPTY_STRING));

      try

      {

         // parse the ejbql into an abstract sytax tree

         ASTEJBQL ejbqlNode;

         ejbqlNode = parser.parse(catalog, parameterTypes, ejbql);

         // translate to sql

         sql = ejbqlNode.jjtAccept(this, new StringBuffer()).toString();

      }

      catch(Exception e)

      {

         // if there is a problem reset the state before exiting

         reset();

         throw e;

      }

      catch(Error e)

      {

         // lame javacc lexer throws Errors

         reset();

         throw e;

      }

   }

   public void compileJBossQL(String ejbql,

                              Class returnType,

                              Class[] parameterTypes,

                              JDBCQueryMetaData metadata)

      throws Exception

   {

      // reset all state variables

      reset();

      // set input arguemts

      this.returnType = returnType;

      this.parameterTypes = parameterTypes;

      this.readAhead = metadata.getReadAhead();

      this.lazyResultSetLoading = metadata.isLazyResultSetLoading();

      // get the parser

      JBossQLParser parser = new JBossQLParser(new StringReader(SQLUtil.EMPTY_STRING));

      try

      {

         // parse the ejbql into an abstract sytax tree

         ASTEJBQL ejbqlNode;

         ejbqlNode = parser.parse(catalog, parameterTypes, ejbql);

         // translate to sql

         sql = ejbqlNode.jjtAccept(this, new StringBuffer()).toString();

      }

      catch(Exception e)

      {

         // if there is a problem reset the state before exiting

         reset();

         throw e;

      }

      catch(Error e)

      {

         // lame javacc lexer throws Errors

         reset();

         throw e;

      }

   }

   private void reset()

   {

      returnType = null;

      parameterTypes = null;

      readAhead = null;

      inputParameters.clear();

      declaredPaths.clear();

      clearPerTermJoinPaths();

      allJoinPaths.clear();

      allCollectionMemberJoinPaths.clear();

      allLeftJoinPaths.clear();

      selectObject = null;

      selectManager = null;

      typeFactory = null;

      typeMapping = null;

      aliasManager = null;

      subquerySupported = true;

      forceDistinct = false;

      limitParam = 0;

      limitValue = 0;

      offsetParam = 0;

      offsetValue = 0;

      leftJoinCMRList.clear();

      onFindCMRJoin = null;

      countCompositePk = false;

      selectAlias = null;

      selectDistinct = false;

      functionJDBCType = null;

   }

   public String getSQL()

   {

      return sql;

   }

   public int getOffsetValue()

   {

      return offsetValue;

   }

   public int getOffsetParam()

   {

      return offsetParam;

   }

   public int getLimitValue()

   {

      return limitValue;

   }

   public int getLimitParam()

   {

      return limitParam;

   }

   public boolean isSelectEntity()

   {

      return selectObject instanceof JDBCEntityBridge;

   }

   public JDBCAbstractEntityBridge getSelectEntity()

   {

      return (JDBCAbstractEntityBridge) selectObject;

   }

   public boolean isSelectField()

   {

      return selectObject instanceof JDBCCMPFieldBridge;

   }

   public JDBCFieldBridge getSelectField()

   {

      return (JDBCCMPFieldBridge) selectObject;

   }

   public SelectFunction getSelectFunction()

   {

      return (SelectFunction) selectObject;

   }

   public EntityPersistenceStore getStoreManager()

   {

      return selectManager;

   }

   public List getInputParameters()

   {

      return inputParameters;

   }

   public List getLeftJoinCMRList()

   {

      return leftJoinCMRList;

   }

   public boolean isSelectDistinct()

   {

      return selectDistinct;

   }

   public Object visit(SimpleNode node, Object data)

   {

      throw new RuntimeException("Internal error: Found unknown node type in " +

         "EJB-QL abstract syntax tree: node=" + node);

   }

   private void setTypeFactory(JDBCTypeFactory typeFactory)

   {

      this.typeFactory = typeFactory;

      this.typeMapping = typeFactory.getTypeMapping();

      aliasManager = new AliasManager(typeMapping.getAliasHeaderPrefix(),

         typeMapping.getAliasHeaderSuffix(),

         typeMapping.getAliasMaxLength());

      subquerySupported = typeMapping.isSubquerySupported();

   }

   private Class getParameterType(int index)

   {

      int zeroBasedIndex = index - 1;

      Class[] params = parameterTypes;

      if(zeroBasedIndex < params.length)

      {

         return params[zeroBasedIndex];

      }

      return null;

   }

   // verify that parameter is the same type as the entity

   private void verifyParameterEntityType(int number,

                                          JDBCEntityBridge entity)

   {

      Class parameterType = getParameterType(number);

      Class remoteClass = entity.getMetaData().getRemoteClass();

      Class localClass = entity.getMetaData().getLocalClass();

      if((

         localClass == null ||

         !localClass.isAssignableFrom(parameterType)

         ) &&

         (

         remoteClass == null ||

         !remoteClass.isAssignableFrom(parameterType)

         ))

      {

         throw new IllegalStateException("Only like types can be " +

            "compared: from entity=" +

            entity.getEntityName() +

            " to parameter type=" + parameterType);

      }

   }

   private void compareEntity(boolean not,

                              Node fromNode,

                              Node toNode,

                              StringBuffer buf)

   {

      buf.append('(');

      if(not)

      {

         buf.append(SQLUtil.NOT).append('(');

      }

      String fromAlias;

      JDBCEntityBridge fromEntity;

      ASTPath fromPath = (ASTPath) fromNode;

      addJoinPath(fromPath);

      fromAlias = aliasManager.getAlias(fromPath.getPath());

      fromEntity = (JDBCEntityBridge) fromPath.getEntity();

      if(toNode instanceof ASTParameter)

      {

         ASTParameter toParam = (ASTParameter) toNode;

         // can only compare like kind entities

         verifyParameterEntityType(toParam.number, fromEntity);

         inputParameters.addAll(QueryParameter.createParameters(toParam.number - 1, fromEntity));

         SQLUtil.getWhereClause(fromEntity.getPrimaryKeyFields(), fromAlias, buf);

      }

      else

      {

         String toAlias;

         JDBCEntityBridge toEntity;

         ASTPath toPath = (ASTPath) toNode;

         addJoinPath(toPath);

         toAlias = aliasManager.getAlias(toPath.getPath());

         toEntity = (JDBCEntityBridge) toPath.getEntity();

         // can only compare like kind entities

         if(!fromEntity.equals(toEntity))

         {

            throw new IllegalStateException("Only like types can be " +

               "compared: from entity=" +

               fromEntity.getEntityName() +

               " to entity=" + toEntity.getEntityName());

         }

         SQLUtil.getSelfCompareWhereClause(fromEntity.getPrimaryKeyFields(), fromAlias, toAlias, buf);

      }

      if(not)

      {

         buf.append(')');

      }

      buf.append(')');

   }

   private void existsClause(ASTPath path, StringBuffer buf, boolean not)

   {

      if(!path.isCMRField())

      {

         throw new IllegalArgumentException("path must be a cmr field");

      }

      JDBCCMRFieldBridge cmrField = (JDBCCMRFieldBridge) path.getCMRField();

      String pathStr = path.getPath(path.size() - 2);

      String parentAlias = aliasManager.getAlias(pathStr);

      // if exists is not supported we use a left join and is null

      if(!subquerySupported)

      {

         // add the path to the list of paths to left join

         addLeftJoinPath(pathStr, path);

         forceDistinct = true;

         addJoinPath(path);

         if(cmrField.getRelationMetaData().isForeignKeyMappingStyle())

         {

            JDBCEntityBridge childEntity = (JDBCEntityBridge) cmrField.getRelatedEntity();

            String childAlias = aliasManager.getAlias(path.getPath());

            SQLUtil.getIsNullClause(!not, childEntity.getPrimaryKeyFields(), childAlias, buf);

         }

         else

         {

            String relationTableAlias = aliasManager.getRelationTableAlias(path.getPath());

            SQLUtil.getIsNullClause(!not, cmrField.getTableKeyFields(), relationTableAlias, buf);

         }

         return;

      }

      if(not)

      {

         buf.append(SQLUtil.NOT);

      }

      buf.append(SQLUtil.EXISTS).append('(');

      if(cmrField.getRelationMetaData().isForeignKeyMappingStyle())

      {

         JDBCEntityBridge childEntity = (JDBCEntityBridge) cmrField.getRelatedEntity();

         String childAlias = aliasManager.getAlias(path.getPath());

         buf.append(SQLUtil.SELECT);

         SQLUtil.getColumnNamesClause(childEntity.getPrimaryKeyFields(), childAlias, buf)

            .append(SQLUtil.FROM)

            .append(childEntity.getQualifiedTableName()).append(' ').append(childAlias)

            .append(SQLUtil.WHERE);

         SQLUtil.getJoinClause(cmrField, parentAlias, childAlias, buf);

      }

      else

      {

         String relationTableAlias = aliasManager.getRelationTableAlias(path.getPath());

         buf.append(SQLUtil.SELECT);

         SQLUtil.getColumnNamesClause(cmrField.getTableKeyFields(), relationTableAlias, buf)

            .append(SQLUtil.FROM)

            .append(cmrField.getQualifiedTableName())

            .append(' ')

            .append(relationTableAlias)

            .append(SQLUtil.WHERE);

         SQLUtil.getRelationTableJoinClause(cmrField, parentAlias, relationTableAlias, buf);

      }

      buf.append(')');

   }

   public Object visit(ASTEJBQL node, Object data)

   {

      Node selectNode = node.jjtGetChild(0);

      Node fromNode = node.jjtGetChild(1);

      Node whereNode = null;

      Node orderByNode = null;

      Node limitNode = null;

      for(int childNode = 2; childNode < node.jjtGetNumChildren(); childNode++)

      {

         Node temp = node.jjtGetChild(childNode);

         if(temp instanceof ASTWhere)

         {

            whereNode = temp;

         }

         else if(temp instanceof ASTOrderBy)

         {

            orderByNode = temp;

         }

         else if(temp instanceof ASTLimitOffset)

         {

            limitNode = temp;

         }

      }

      // translate select and add it to the buffer

      StringBuffer select = new StringBuffer();

      selectNode.jjtAccept(this, select);

      // conditional term paths from the where clause are treated separately from those

      // in select, from and order by.

      // TODO come up with a nicer treatment implementation.

      Set selectJoinPaths = new HashSet(ctermJoinPaths);

      Map selectCollectionMemberJoinPaths = new HashMap(ctermCollectionMemberJoinPaths);

      Map selectLeftJoinPaths = new HashMap(ctermLeftJoinPaths);

      // translate where and save results to append later

      StringBuffer where = new StringBuffer();

      if(whereNode != null)

      {

         whereNode.jjtAccept(this, where);

      }

      // reassign conditional term paths and add paths from order by and from to select paths

      ctermJoinPaths = selectJoinPaths;

      ctermCollectionMemberJoinPaths = selectCollectionMemberJoinPaths;

      ctermLeftJoinPaths = selectLeftJoinPaths;

      // translate order by and save results to append later

      StringBuffer orderBy = new StringBuffer();

      if(orderByNode != null)

      {

         orderByNode.jjtAccept(this, orderBy);

         // hack alert - this should use the visitor approach

         for(int i = 0; i < orderByNode.jjtGetNumChildren(); i++)

         {

            Node orderByPath = orderByNode.jjtGetChild(i);

            ASTPath path = (ASTPath) orderByPath.jjtGetChild(0);

            if(!isSelected(path))

            {

               select.append(SQLUtil.COMMA);

               path.jjtAccept(this, select);

            }

         }

      }

      if(limitNode != null)

      {

         limitNode.jjtAccept(this, null);

      }

      StringBuffer from = new StringBuffer(50);

      fromNode.jjtAccept(this, from);

      StringBuffer fromThetaJoin = new StringBuffer();

      createThetaJoin(fromThetaJoin);

      if(where.length() != 0 && fromThetaJoin.length() != 0)

      {

         where.insert(0, '(')

            .append(')')

            .append(SQLUtil.AND)

            .append(fromThetaJoin);

      }

      else if(fromThetaJoin.length() != 0)

      {

         where.append(fromThetaJoin.toString());

      }

      selectDistinct = isDistinct(selectNode);

      // select size

      if(lazyResultSetLoading)

      {

         StringBuffer buf = new StringBuffer(200);

         if(isSelectEntity())

         {

            final JDBCFieldBridge[] pkFields = getSelectEntity().getPrimaryKeyFields();

            if(pkFields.length == 1)

            {

               buf.append('(').append(SQLUtil.SELECT).append("count(");

               if(selectDistinct)

               {

                  buf.append(SQLUtil.DISTINCT);

               }

               SQLUtil.getColumnNamesClause(pkFields, selectAlias, buf);

               buf.append(')').append(SQLUtil.FROM);

               buf.append(from);

               if(where.length() > 0)

               {

                  buf.append(SQLUtil.WHERE).append(where);

               }

               buf.append("), ");

               select.insert(0, buf);

            }

            else

            {

               buf.append('(').append(SQLUtil.SELECT).append("count(*)").append(SQLUtil.FROM)

                  .append('(')

                  .append(SQLUtil.SELECT);

               if(selectDistinct)

               {

                  buf.append(SQLUtil.DISTINCT);

               }

               SQLUtil.getColumnNamesClause(pkFields, selectAlias, buf);

               buf.append(SQLUtil.FROM).append(from);

               if(where.length() > 0)

               {

                  buf.append(SQLUtil.WHERE).append(where);

               }

               buf.append(") t_count), ");

               select.insert(0, buf);

            }

         }

         else if(isSelectField())

         {

            buf.append('(').append(SQLUtil.SELECT).append("count(");

            if(selectDistinct)

            {

               buf.append(SQLUtil.DISTINCT);

            }

            buf.append(select).append(')').append(SQLUtil.FROM);

            buf.append(from);

            if(where.length() > 0)

            {

               buf.append(SQLUtil.WHERE).append(where);

            }

            buf.append("), ");

            select.insert(0, buf);

         }

      }

      // distinct

      if(selectDistinct)

      {

         select.insert(0, SQLUtil.DISTINCT);

      }

      StringBuffer buf = (StringBuffer) data;

      if(selectManager.getMetaData().hasRowLocking())

      {

         JDBCFunctionMappingMetaData rowLockingTemplate = typeMapping.getRowLockingTemplate();

         Object args[] = new Object[]{

            select,

            from,

            where.length() == 0 ? null : where,

            orderBy.length() == 0 ? null : orderBy

         };

         rowLockingTemplate.getFunctionSql(args, buf);

      }

      else

      {

         buf.append(SQLUtil.SELECT)

            .append(select)

            .append(SQLUtil.FROM)

            .append(from);

         if(where.length() > 0)

         {

            buf.append(SQLUtil.WHERE)

               .append(where);

         }

         if(orderBy.length() != 0)

         {

            buf.append(SQLUtil.ORDERBY)

               .append(orderBy);

         }

      }

      // todo: ...

      if(countCompositePk)

      {

         buf.insert(0, "SELECT COUNT(*) FROM (").append(") t_count");

      }

      return buf;

   }

   public Object visit(ASTFrom node, Object data)

   {

      StringBuffer buf = (StringBuffer) data;

      node.jjtGetChild(0).jjtAccept(this, buf);

      for(int i = 1; i < node.jjtGetNumChildren(); i++)

      {

         buf.append(SQLUtil.COMMA);

         node.jjtGetChild(i).jjtAccept(this, buf);

      }

      // add all the additional path tables

      if(!allJoinPaths.isEmpty())

      {

         for(Iterator iter = allJoinPaths.iterator(); iter.hasNext();)

         {

            ASTPath path = (ASTPath) iter.next();

            for(int i = 0; i < path.size(); i++)

            {

               declareTables(path, i, buf);

            }

         }

      }

      // add all parent paths for collection member join paths

      if(!allCollectionMemberJoinPaths.isEmpty())

      {

         for(Iterator iter = allCollectionMemberJoinPaths.values().iterator(); iter.hasNext();)

         {

            ASTPath path = (ASTPath) iter.next();

            // don't declare the last one as the first path was left joined

            for(int i = 0; i < path.size() - 1; i++)

            {

               declareTables(path, i, buf);

            }

         }

      }

      // get all the left joined paths

      if(!allLeftJoinPaths.isEmpty())

      {

         Set allLeftJoins = new HashSet();

         for(Iterator iter = allLeftJoinPaths.values().iterator(); iter.hasNext();)

         {

            allLeftJoins.addAll((Set) iter.next());

         }

         // add all parent paths for left joins

         for(Iterator iter = allLeftJoins.iterator(); iter.hasNext();)

         {

            ASTPath path = (ASTPath) iter.next();

            // don't declare the last one as the first path was left joined

            for(int i = 0; i < path.size() - 1; i++)

            {

               declareTables(path, i, buf);

            }

         }

      }

      return buf;

   }

   private void declareTables(ASTPath path, int i, StringBuffer buf)

   {

      if(!path.isCMRField(i) || declaredPaths.contains(path.getPath(i)))

      {

         return;

      }

      JDBCCMRFieldBridge cmrField = (JDBCCMRFieldBridge) path.getCMRField(i);

      JDBCEntityBridge entity = (JDBCEntityBridge) path.getEntity(i);

      buf.append(SQLUtil.COMMA)

         .append(entity.getQualifiedTableName())

         .append(' ')

         .append(aliasManager.getAlias(path.getPath(i)));

      leftJoins(path.getPath(i), buf);

      if(cmrField.getRelationMetaData().isTableMappingStyle())

      {

         String relationTableAlias = aliasManager.getRelationTableAlias(path.getPath(i));

         buf.append(SQLUtil.COMMA)

            .append(cmrField.getQualifiedTableName())

            .append(' ')

            .append(relationTableAlias);

      }

      declaredPaths.add(path.getPath(i));

   }

   private void leftJoins(String parentPath, StringBuffer buf)

   {

      Set paths = (Set) ctermLeftJoinPaths.get(parentPath);

      if(subquerySupported || paths == null)

      {

         return;

      }

      for(Iterator iter = paths.iterator(); iter.hasNext();)

      {

         ASTPath path = (ASTPath) iter.next();

         JDBCCMRFieldBridge cmrField = (JDBCCMRFieldBridge) path.getCMRField();

         String parentAlias = aliasManager.getAlias(parentPath);

         if(cmrField.getRelationMetaData().isForeignKeyMappingStyle())

         {

            JDBCEntityBridge childEntity = (JDBCEntityBridge) cmrField.getRelatedEntity();

            String childAlias = aliasManager.getAlias(path.getPath());

            buf.append(SQLUtil.LEFT_JOIN)

               .append(childEntity.getQualifiedTableName())

               .append(' ')

               .append(childAlias)

               .append(SQLUtil.ON);

            SQLUtil.getJoinClause(cmrField, parentAlias, childAlias, buf);

         }

         else

         {

            String relationTableAlias = aliasManager.getRelationTableAlias(path.getPath());

            buf.append(SQLUtil.LEFT_JOIN)

               .append(cmrField.getQualifiedTableName())

               .append(' ')

               .append(relationTableAlias)

               .append(SQLUtil.ON);

            SQLUtil.getRelationTableJoinClause(cmrField, parentAlias, relationTableAlias, buf);

         }

      }

   }

   private void createThetaJoin(StringBuffer buf)

   {

      Set joinedAliases = new HashSet();

      // add all the additional path tables

      if(!ctermJoinPaths.isEmpty())

      {

         for(Iterator iter = ctermJoinPaths.iterator(); iter.hasNext();)

         {

            ASTPath path = (ASTPath) iter.next();

            for(int i = 0; i < path.size(); i++)

            {

               createThetaJoin(path, i, joinedAliases, buf);

            }

         }

      }

      // add all the collection member path tables

      if(!ctermCollectionMemberJoinPaths.isEmpty())

      {

         for(Iterator iter = ctermCollectionMemberJoinPaths.entrySet().iterator(); iter.hasNext();)

         {

            Map.Entry entry = (Map.Entry) iter.next();

            String childAlias = (String) entry.getKey();

            ASTPath path = (ASTPath) entry.getValue();

            // join the memeber path

            createThetaJoin(path, path.size() - 1, joinedAliases, childAlias, buf);

            // join the memeber path parents

            for(int i = 0; i < path.size() - 1; i++)

            {

               createThetaJoin(path, i, joinedAliases, buf);

            }

         }

      }

      // get all the left joined paths

      if(!ctermLeftJoinPaths.isEmpty())

      {

         Set allLeftJoins = new HashSet();

         for(Iterator iter = ctermLeftJoinPaths.values().iterator(); iter.hasNext();)

         {

            allLeftJoins.addAll((Set) iter.next());

         }

         // add all parent paths for left joins

         for(Iterator iter = allLeftJoins.iterator(); iter.hasNext();)

         {

            ASTPath path = (ASTPath) iter.next();

            // don't declare the last one as the first path was left joined

            for(int i = 0; i < path.size() - 1; i++)

            {

               createThetaJoin(path, i, joinedAliases, buf);

            }

         }

      }

   }

   private void createThetaJoin(ASTPath path,

                                int i,

                                Set joinedAliases,

                                StringBuffer buf)

   {

      String childAlias = aliasManager.getAlias(path.getPath(i));

      createThetaJoin(path, i, joinedAliases, childAlias, buf);

   }

   private void createThetaJoin(ASTPath path,

                                int i,

                                Set joinedAliases,

                                String childAlias,

                                StringBuffer buf)

   {

      if(!path.isCMRField(i) || joinedAliases.contains(childAlias))

      {

         return;

      }

      JDBCCMRFieldBridge cmrField = (JDBCCMRFieldBridge) path.getCMRField(i);

      String parentAlias = aliasManager.getAlias(path.getPath(i - 1));

      if(joinedAliases.size() > 0)

      {

         buf.append(SQLUtil.AND);

      }

      if(cmrField.getRelationMetaData().isForeignKeyMappingStyle())

      {

         SQLUtil.getJoinClause(cmrField, parentAlias, childAlias, buf);

      }

      else

      {

         String relationTableAlias = aliasManager.getRelationTableAlias(path.getPath(i));

         // parent to relation table

         SQLUtil.getRelationTableJoinClause(cmrField, parentAlias, relationTableAlias, buf)

            .append(SQLUtil.AND);

         // child to relation table

         SQLUtil.getRelationTableJoinClause(cmrField.getRelatedCMRField(), childAlias, relationTableAlias, buf);

      }

      joinedAliases.add(childAlias);

   }

   public Object visit(ASTCollectionMemberDeclaration node, Object data)

   {

      StringBuffer buf = (StringBuffer) data;

      // first arg is a collection valued path

      ASTPath path = (ASTPath) node.jjtGetChild(0);

      // add this path to the list of declared paths

      declaredPaths.add(path.getPath());

      // get the entity at the end of this path

      JDBCEntityBridge entity = (JDBCEntityBridge) path.getEntity();

      // second arg is the identifier

      ASTIdentifier id = (ASTIdentifier) node.jjtGetChild(1);

      // get the alias

      String alias = aliasManager.getAlias(id.identifier);

      // add this path to the list of join paths so parent paths will be joined

      addCollectionMemberJoinPath(alias, path);

      // declare the alias mapping

      aliasManager.addAlias(path.getPath(), alias);

      buf.append(entity.getQualifiedTableName());

      buf.append(' ');

      buf.append(alias);

      leftJoins(path.getPath(), buf);

      if(onFindCMRJoin != null && alias.equals(selectAlias))

      {

         buf.append(onFindCMRJoin);

         onFindCMRJoin = null;

      }

      // add the relation-table

      JDBCCMRFieldBridge cmrField = (JDBCCMRFieldBridge) path.getCMRField();

      if(cmrField.getRelationMetaData().isTableMappingStyle())

      {

         String relationTableAlias = aliasManager.getRelationTableAlias(path.getPath());

         buf.append(SQLUtil.COMMA)

            .append(cmrField.getQualifiedTableName())

            .append(' ')

            .append(relationTableAlias);

      }

      return buf;

   }

   public Object visit(ASTRangeVariableDeclaration node, Object data)

   {

      StringBuffer buf = (StringBuffer) data;

      ASTAbstractSchema schema = (ASTAbstractSchema) node.jjtGetChild(0);

      JDBCEntityBridge entity = (JDBCEntityBridge) schema.entity;

      ASTIdentifier id = (ASTIdentifier) node.jjtGetChild(1);

      String alias = aliasManager.getAlias(id.identifier);

      buf.append(entity.getQualifiedTableName())

         .append(' ')

         .append(alias);

      leftJoins(id.identifier, buf);

      if(onFindCMRJoin != null && alias.equals(selectAlias))

      {

         buf.append(onFindCMRJoin);

         onFindCMRJoin = null;

      }

      return buf;

   }

   public Object visit(ASTSelect node, Object data)

   {

      StringBuffer buf = (StringBuffer) data;

      Node child0 = node.jjtGetChild(0);

      ASTPath path;

      if(child0 instanceof ASTPath)

      {

         path = (ASTPath) child0;

         if(path.isCMPField())

         {

            // set the select object

            JDBCCMPFieldBridge selectField = (JDBCCMPFieldBridge) path.getCMPField();

            selectManager = (JDBCStoreManager) selectField.getManager();

            selectObject = selectField;

            setTypeFactory(selectManager.getJDBCTypeFactory());

            addJoinPath(path);

            selectAlias = aliasManager.getAlias(path.getPath(path.size() - 2));

            SQLUtil.getColumnNamesClause(selectField, selectAlias, buf);

         }

         else

         {

            // set the select object

            JDBCEntityBridge selectEntity = (JDBCEntityBridge) path.getEntity();

            selectManager = (JDBCStoreManager) selectEntity.getManager();

            selectObject = selectEntity;

            setTypeFactory(selectManager.getJDBCTypeFactory());

            selectEntity(path, node.distinct, buf);

         }

      }

      else

      {

         // the function should take a path expresion as a parameter

         path = getPathFromChildren(child0);

         if(path == null)

         {

            throw new IllegalStateException("The function in SELECT clause does not contain a path expression.");

         }

         if(path.isCMPField())

         {

            JDBCCMPFieldBridge selectField = (JDBCCMPFieldBridge) path.getCMPField();

            selectManager = (JDBCStoreManager) selectField.getManager();

            if(selectField.getJDBCType().hasMapper())

               this.functionJDBCType = selectField.getJDBCType();

         }

         else if(path.isCMRField())

         {

            JDBCCMRFieldBridge cmrField = (JDBCCMRFieldBridge) path.getCMRField();

            selectManager = (JDBCStoreManager) cmrField.getEntity().getManager();

            addJoinPath(path);

         }

         else

         {

            final JDBCEntityBridge entity = (JDBCEntityBridge) path.getEntity();

            selectManager = (JDBCStoreManager) entity.getManager();

            addJoinPath(path);

         }

         setTypeFactory(selectManager.getJDBCTypeFactory());

         selectObject = child0;

         child0.jjtAccept(this, buf);

      }

      return buf;

   }

   /**

    * Generates where clause without the "WHERE" keyword.

    */

   public Object visit(ASTWhere node, Object data)

   {

      node.jjtGetChild(0).jjtAccept(this, data);