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);
                        }
                    }
                }
            }
        }
Beispiel #2
0
        public void Token(string token, QueryTranslator q)
        {
            // start by looking for HQL keywords....
            string lcToken = token.ToLower(System.Globalization.CultureInfo.InvariantCulture);

            if (lcToken.Equals(StringHelper.Comma))
            {
                if (!(expectingJoin | expectingAs))
                {
                    throw new QueryException("unexpected token: ,");
                }
                expectingJoin = false;
                expectingAs   = false;
            }
            else if (lcToken.Equals("join"))
            {
                if (!afterJoinType)
                {
                    if (!(expectingJoin | expectingAs))
                    {
                        throw new QueryException("unexpected token: join");
                    }
                    // inner joins can be abbreviated to 'join'
                    joinType      = JoinType.InnerJoin;
                    expectingJoin = false;
                    expectingAs   = false;
                }
                else
                {
                    afterJoinType = false;
                }
            }
            else if (lcToken.Equals("fetch"))
            {
                if (q.IsShallowQuery)
                {
                    throw new QueryException("fetch may not be used with scroll() or iterate()");
                }
                if (joinType == JoinType.None)
                {
                    throw new QueryException("unexpected token: fetch");
                }
                if (joinType == JoinType.FullJoin || joinType == JoinType.RightOuterJoin)
                {
                    throw new QueryException("fetch may only be used with inner join or left outer join");
                }
                afterFetch = true;
            }
            else if (lcToken.Equals("outer"))
            {
                // 'outer' is optional and is ignored)
                if (!afterJoinType || (joinType != JoinType.LeftOuterJoin && joinType != JoinType.RightOuterJoin))
                {
                    throw new QueryException("unexpected token: outer");
                }
            }
            else if (joinTypes.Contains(lcToken))
            {
                if (!(expectingJoin | expectingAs))
                {
                    throw new QueryException("unexpected token: " + token);
                }
                joinType      = ( JoinType )joinTypes[lcToken];
                afterJoinType = true;
                expectingJoin = false;
                expectingAs   = false;
            }
            else if (lcToken.Equals("class"))
            {
                if (!afterIn)
                {
                    throw new QueryException("unexpected token: class");
                }
                if (joinType != JoinType.None)
                {
                    throw new QueryException("outer or full join must be followed by path expression");
                }
                afterClass = true;
            }
            else if (lcToken.Equals("in"))
            {
                if (!expectingIn)
                {
                    throw new QueryException("unexpected token: in");
                }
                afterIn     = true;
                expectingIn = false;
            }
            else if (lcToken.Equals("as"))
            {
                if (!expectingAs)
                {
                    throw new QueryException("unexpected token: as");
                }
                afterAs     = true;
                expectingAs = false;
            }
            else
            {
                if (afterJoinType)
                {
                    throw new QueryException("join expected: " + token);
                }
                if (expectingJoin)
                {
                    throw new QueryException("unexpected token: " + token);
                }
                if (expectingIn)
                {
                    throw new QueryException("in expected: " + token);
                }

                // now anything that is not a HQL keyword

                if (afterAs || expectingAs)
                {
                    // (AS is always optional, for consistentcy with SQL/OQL

                    // process the "new" HQL stype where aliases are assigned
                    // _after_ the class name or path expression ie using the
                    // AS construction

                    if (entityName != null)
                    {
                        q.SetAliasName(token, entityName);
                    }
                    else
                    {
                        throw new QueryException("unexpected: as " + token);
                    }
                    afterAs       = false;
                    expectingJoin = true;
                    expectingAs   = false;
                    entityName    = null;
                }
                else if (afterIn)
                {
                    // process the "old" HQL style where aliases appear _first
                    // ie using the IN or IN CLASS constructions

                    if (alias == null)
                    {
                        throw new QueryException("alias not specified for: " + token);
                    }

                    if (joinType != JoinType.None)
                    {
                        throw new QueryException("outer or full join must be followed by path expressions");
                    }

                    if (afterClass)
                    {
                        // treat it as a classname
                        IQueryable p = q.GetPersisterUsingImports(token);
                        if (p == null)
                        {
                            throw new QueryException("persister not found: " + token);
                        }
                        q.AddFromClass(alias, p);
                    }
                    else
                    {
                        // treat it as a path expression
                        peParser.JoinType          = JoinType.InnerJoin;
                        peParser.UseThetaStyleJoin = true;
                        ParserHelper.Parse(peParser, q.Unalias(token), ParserHelper.PathSeparators, q);
                        if (!peParser.IsCollectionValued)
                        {
                            throw new QueryException("pathe expression did not resolve to collection: " + token);
                        }
                        string nm = peParser.AddFromCollection(q);
                        q.SetAliasName(alias, nm);
                    }

                    alias         = null;
                    afterIn       = false;
                    afterClass    = false;
                    expectingJoin = true;
                }
                else
                {
                    // handle a path expression or class name that appears
                    // at the start, in the "new" HQL style or an alias that
                    // appears at the start in the "old HQL stype
                    IQueryable p = q.GetPersisterUsingImports(token);
                    if (p != null)
                    {
                        // starts with the name of a mapped class (new style)
                        if (joinType != JoinType.None)
                        {
                            throw new QueryException("outer or full join must be followed by path expression");
                        }
                        entityName = q.CreateNameFor(p.MappedClass);
                        q.AddFromClass(entityName, p);
                        expectingAs = true;
                    }
                    else if (token.IndexOf('.') < 0)
                    {
                        // starts with an alias (old style)
                        // semi-bad thing about this: can't re-alias another alias...
                        alias       = token;
                        expectingIn = true;
                    }
                    else
                    {
                        // starts with a path expression (new style)

                        // force HQL style: from Person p inner join p.cars c
                        //if (joinType==JoinType.None) throw new QueryException("path expression must be preceded by full, left, right or inner join");

                        //allow ODMG OQL style: from Person p, p.cars c
                        if (joinType != JoinType.None)
                        {
                            peParser.JoinType = joinType;
                        }
                        else
                        {
                            peParser.JoinType = JoinType.InnerJoin;
                        }
                        peParser.UseThetaStyleJoin = q.IsSubquery;

                        ParserHelper.Parse(peParser, q.Unalias(token), ParserHelper.PathSeparators, q);
                        entityName = peParser.AddFromAssociation(q);

                        joinType          = JoinType.None;
                        peParser.JoinType = JoinType.InnerJoin;

                        if (afterFetch)
                        {
                            peParser.Fetch(q, entityName);
                            afterFetch = false;
                        }

                        expectingAs = true;
                    }
                }
            }
        }