public void Token(string token, QueryTranslator q)
 {
     if (q.IsName(StringHelper.Root(token)))
     {
         ParserHelper.Parse(pathExpressionParser, q.Unalias(token), ParserHelper.PathSeparators, q);
         q.AppendGroupByToken(pathExpressionParser.WhereColumn);
         pathExpressionParser.AddAssociation(q);
     }
     else
     {
         q.AppendGroupByToken(token);
     }
 }
Beispiel #2
0
 public void Token(string token, QueryTranslator q)
 {
     if (q.IsName(StringHelper.Root(token)))
     {
         ParserHelper.Parse(pathExpressionParser, q.Unalias(token), ParserHelper.PathSeparators, q);
         q.AppendGroupByToken(pathExpressionParser.WhereColumn);
         pathExpressionParser.AddAssociation(q);
     }
     else if (token.StartsWith(ParserHelper.HqlVariablePrefix))
     {
         q.AddNamedParameter(token.Substring(1));
         q.AppendGroupByParameter();
     }
     else
     {
         q.AppendGroupByToken(token);
     }
 }
 /// <summary>
 ///
 /// </summary>
 /// <param name="token"></param>
 /// <param name="q"></param>
 public void Token(string token, QueryTranslator q)
 {
     if (q.IsName(StringHelper.Root(token)))
     {
         ParserHelper.Parse(pathExpressionParser, q.Unalias(token), ParserHelper.PathSeparators, q);
         q.AppendOrderByToken(pathExpressionParser.WhereColumn);
         pathExpressionParser.AddAssociation(q);
     }
     else if (token.StartsWith(ParserHelper.HqlVariablePrefix))
     {
         q.AddNamedParameter(token.Substring(1));
         // this is only a temporary parameter to help with the parsing of hql -
         // when the type becomes known then this will be converted to its real
         // parameter type.
         //AppendToken( q, new SqlString( new object[ ] {new Parameter( StringHelper.SqlParameter )} ) );
     }
     else
     {
         q.AppendOrderByToken(token);
     }
 }
        private void DoToken(string token, QueryTranslator q)
        {
            SessionFactoryHelper helper = new SessionFactoryHelper(q.Factory);

            if (q.IsName(StringHelper.Root(token)))             //path expression
            {
                DoPathExpression(q.Unalias(token), q);
            }
            else if (token.StartsWith(ParserHelper.HqlVariablePrefix))             //named query parameter
            {
                var name = token.Substring(1);
                // this is only a temporary parameter to help with the parsing of hql -
                // when the type becomes known then this will be converted to its real
                // parameter type.
                AppendToken(q, q.GetNamedParameter(name));
            }
            else if (token.Equals(StringHelper.SqlParameter))
            {
                //if the token is a "?" then we have a Parameter so convert it to a SqlCommand.Parameter
                // instead of appending a "?" to the WhereTokens
                AppendToken(q, q.GetPositionalParameter());
            }
            else
            {
                IQueryable persister = q.GetPersisterUsingImports(token);
                if (persister != null)                 // the name of a class
                {
                    string discrim = persister.DiscriminatorSQLValue;
                    if (InFragment.Null == discrim || InFragment.NotNull == discrim)
                    {
                        throw new QueryException("subclass test not allowed for null or not null discriminator");
                    }
                    AppendToken(q, discrim);
                }
                else
                {
                    object      constant;
                    string      fieldName    = null;
                    System.Type importedType = null;

                    int indexOfDot = token.IndexOf(StringHelper.Dot);
                    // don't even bother to do the lookups if the indexOfDot is not
                    // greater than -1.  This will save all the string modifications.

                    // This allows us to resolve to the full type before obtaining the value e.g. FooStatus.OFF -> NHibernate.Model.FooStatus.OFF
                    if (indexOfDot > -1)
                    {
                        fieldName = StringHelper.Unqualify(token);
                        string typeName = StringHelper.Qualifier(token);
                        importedType = helper.GetImportedClass(typeName);
                    }

                    if (indexOfDot > -1 && importedType != null &&
                        (constant = ReflectHelper.GetConstantValue(importedType, fieldName)) != null)
                    {
                        // need to get the NHibernate Type so we can convert the Enum or field from
                        // a class into it's string representation for hql.
                        IType type;
                        try
                        {
                            type = TypeFactory.HeuristicType(constant.GetType().AssemblyQualifiedName);
                        }
                        catch (MappingException me)
                        {
                            throw new QueryException(me);
                        }

                        if (type == null)
                        {
                            throw new QueryException(string.Format("Could not determin the type of: {0}", token));
                        }

                        try
                        {
                            AppendToken(q, ((ILiteralType)type).ObjectToSQLString(constant, q.Factory.Dialect));
                        }
                        catch (Exception e)
                        {
                            throw new QueryException("Could not format constant value to SQL literal: " + token, e);
                        }
                    }
                    else
                    {
                        //anything else
                        string negatedToken = null;
                        if (negated)
                        {
                            negations.TryGetValue(token.ToLowerInvariant(), out negatedToken);
                        }
                        if (negatedToken != null && (!betweenSpecialCase || !"or".Equals(negatedToken)))
                        {
                            AppendToken(q, negatedToken);
                        }
                        else
                        {
                            AppendToken(q, token);
                        }
                    }
                }
            }
        }
        public void Token(string token, QueryTranslator q)
        {
            if (token != null)
            {
                path.Append(token);
            }

            string alias = q.GetPathAlias(path.ToString());

            if (alias != null)
            {
                Reset(q);                       //reset the dotcount (but not the path)
                currentName            = alias; //after reset!
                currentPropertyMapping = q.GetPropertyMapping(currentName);
                if (!ignoreInitialJoin)
                {
                    JoinSequence ojf = q.GetPathJoin(path.ToString());
                    try
                    {
                        joinSequence.AddCondition(ojf.ToJoinFragment(q.EnabledFilters, true).ToWhereFragmentString);                         //after reset!
                    }
                    catch (MappingException me)
                    {
                        throw new QueryException(me);
                    }
                    // we don't need to worry about any condition in the ON clause
                    // here (toFromFragmentString), since anything in the ON condition
                    // is already applied to the whole query
                }
            }
            else if (".".Equals(token))
            {
                dotcount++;
            }
            else
            {
                if (dotcount == 0)
                {
                    if (!continuation)
                    {
                        if (!q.IsName(token))
                        {
                            throw new QueryException("undefined alias or unknown mapping: " + token);
                        }
                        currentName            = token;
                        currentPropertyMapping = q.GetPropertyMapping(currentName);
                    }
                }
                else if (dotcount == 1)
                {
                    if (currentName != null)
                    {
                        currentProperty = token;
                    }
                    else if (collectionName != null)
                    {
                        //IQueryableCollection p = q.GetCollectionPersister( collectionRole );
                        //DoCollectionProperty( token, p, collectionName );
                        continuation = false;
                    }
                    else
                    {
                        throw new QueryException("unexpected");
                    }
                }
                else
                {
                    // dotcount>=2

                    // Do the corresponding RHS
                    IType propertyType = PropertyType;

                    if (propertyType == null)
                    {
                        throw new QueryException("unresolved property: " + currentProperty);
                    }

                    if (propertyType.IsComponentType)
                    {
                        DereferenceComponent(token);
                    }
                    else if (propertyType.IsEntityType)
                    {
                        DereferenceEntity(token, (EntityType)propertyType, q);
                    }
                    else if (propertyType.IsCollectionType)
                    {
                        DereferenceCollection(token, ((CollectionType)propertyType).Role, q);
                    }
                    else if (token != null)
                    {
                        throw new QueryException("dereferenced: " + currentProperty);
                    }
                }
            }
        }