/// <summary> /// /// </summary> /// <param name="q"></param> /// <param name="token"></param> protected virtual void AppendToken( QueryTranslator q, string token ) { if( expectingIndex > 0 ) { pathExpressionParser.LastCollectionElementIndexValue = token; } else { // a String.Empty can get passed in here. If that occurs // then don't create a new SqlString for it - just ignore // it since it adds nothing to the sql being generated. if( token != null && token.Length > 0 ) { q.AppendWhereToken( new SqlString( token ) ); } } }
/// <summary> /// /// </summary> /// <param name="q"></param> /// <param name="token"></param> protected virtual void AppendToken( QueryTranslator q, SqlString token ) { if( expectingIndex > 0 ) { pathExpressionParser.LastCollectionElementIndexValue = token.ToString(); } else { q.AppendWhereToken( token ); } }
private void DoToken( string token, QueryTranslator q ) { if( q.IsName( StringHelper.Root( token ) ) ) //path expression { DoPathExpression( q.Unalias( token ), q ); } else if( token.StartsWith( ParserHelper.HqlVariablePrefix ) ) //named query parameter { 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 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 q.AppendWhereToken( new SqlString( new object[ ] {new Parameter( StringHelper.SqlParameter)} ) ); } else { IQueryable persister = q.GetPersisterUsingImports( token ); if( persister != null ) // the name of a class { object 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.ToString() ); } else { object constant; string fieldName = null; string typeName = null; string importedName = 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 ); typeName = StringHelper.Qualifier( token ); importedName = q.factory.GetImportedClassName( typeName ); } if( indexOfDot > - 1 && ( constant = ReflectHelper.GetConstantValue( importedName, 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 ) ); } catch( Exception e ) { throw new QueryException( "Could not format constant value to SQL literal: " + token, e ); } } else { //anything else string negatedToken = negated ? ( string ) negations[ token.ToLower( System.Globalization.CultureInfo.InvariantCulture ) ] : null; if( negatedToken != null && ( !betweenSpecialCase || !"or".Equals( negatedToken ) ) ) { AppendToken( q, negatedToken ); } else { AppendToken( q, token ); } } } } }