public void NotSoSimpleWithDelimiters() { string s = "The lazy... I don't know "; StringTokenizer st = new StringTokenizer(s, " .", true); IEnumerator enumerator = st.GetEnumerator(); enumerator.MoveNext(); Assert.AreEqual("The", (string) enumerator.Current, "Can't get first token"); enumerator.MoveNext(); Assert.AreEqual(" ", (string) enumerator.Current, "Can't get first space"); enumerator.MoveNext(); Assert.AreEqual("lazy", (string) enumerator.Current, "Can't get second token"); enumerator.MoveNext(); Assert.AreEqual(".", (string) enumerator.Current, "Can't get first dot"); enumerator.MoveNext(); Assert.AreEqual(".", (string) enumerator.Current, "Can't get second dot"); enumerator.MoveNext(); Assert.AreEqual(".", (string) enumerator.Current, "Can't get third dot"); enumerator.MoveNext(); Assert.AreEqual(" ", (string) enumerator.Current, "Can't get second space"); enumerator.MoveNext(); Assert.AreEqual("I", (string) enumerator.Current, "Can't get third token"); enumerator.MoveNext(); Assert.AreEqual(" ", (string) enumerator.Current, "Can't get third space"); enumerator.MoveNext(); Assert.AreEqual("don't", (string) enumerator.Current, "Can't get fourth token"); enumerator.MoveNext(); Assert.AreEqual(" ", (string) enumerator.Current, "Can't get fourth space"); enumerator.MoveNext(); Assert.AreEqual("know", (string) enumerator.Current, "Can't get fifth token"); enumerator.MoveNext(); Assert.AreEqual(" ", (string) enumerator.Current, "Can't get last space"); Assert.AreEqual(false, enumerator.MoveNext(), "Still thinking there are more tokens"); }
protected static void BindIndex(XmlAttribute indexAttribute, Table table, Column column) { if (indexAttribute != null && table != null) { StringTokenizer tokens = new StringTokenizer(indexAttribute.Value, ", "); foreach (string token in tokens) table.GetOrCreateIndex(token).AddColumn(column); } }
public static void Parse(IParser p, string text, string seperators, QueryTranslator q) { StringTokenizer tokens = new StringTokenizer(text, seperators, true); p.Start(q); foreach (string token in tokens) { p.Token(token, q); } p.End(q); }
public void SimpleStringWithoutDelimiters() { string s = "Hello world!"; StringTokenizer st = new StringTokenizer(s); IEnumerator enumerator = st.GetEnumerator(); enumerator.MoveNext(); Assert.AreEqual("Hello", (string) enumerator.Current, "Can't get first token"); enumerator.MoveNext(); Assert.AreEqual("world!", (string) enumerator.Current, "Can't get second token"); Assert.AreEqual(false, enumerator.MoveNext(), "Still thinking there are more tokens"); }
private static string Format(string sql) { if (sql.IndexOf("\"") > 0 || sql.IndexOf("'") > 0) { return sql; } string formatted; if (sql.ToLower(System.Globalization.CultureInfo.InvariantCulture).StartsWith("create table")) { StringBuilder result = new StringBuilder(60); StringTokenizer tokens = new StringTokenizer(sql, "(,)", true); int depth = 0; foreach (string tok in tokens) { if (StringHelper.ClosedParen.Equals(tok)) { depth--; if (depth == 0) { result.AppendLine(); } } result.Append(tok); if (StringHelper.Comma.Equals(tok) && depth == 1) { result.AppendLine().Append(' '); } if (StringHelper.OpenParen.Equals(tok)) { depth++; if (depth == 1) { result.AppendLine().Append(' '); } } } formatted = result.ToString(); } else { formatted = sql; } return formatted; }
/// <summary> /// /// </summary> /// <param name="property"></param> /// <param name="delim"></param> /// <param name="properties"></param> /// <returns></returns> public static IDictionary ToDictionary( string property, string delim, IDictionary properties ) { IDictionary map = new Hashtable(); string propValue = ( string ) properties[ property ]; if( propValue != null ) { StringTokenizer tokens = new StringTokenizer( propValue, delim, false ); IEnumerator en = tokens.GetEnumerator(); while( en.MoveNext() ) { string key = ( string ) en.Current; string value = en.MoveNext() ? ( string ) en.Current : String.Empty; map[ key ] = value; } } return map; }
public static IDictionary<string, string> ToDictionary(string property, string delim, IDictionary<string, string> properties) { IDictionary<string, string> map = new Dictionary<string, string>(); if (properties.ContainsKey(property)) { string propValue = properties[property]; StringTokenizer tokens = new StringTokenizer(propValue, delim, false); IEnumerator<string> en = tokens.GetEnumerator(); while (en.MoveNext()) { string key = en.Current; string value = en.MoveNext() ? en.Current : String.Empty; map[key] = value; } } return map; }
public StringTokenizerEnumerator( StringTokenizer stok ) { _stokenizer = stok; }
protected static void BindUniqueKey(XmlAttribute uniqueKeyAttribute, Table table, Column column) { if (uniqueKeyAttribute != null && table != null) { StringTokenizer tokens = new StringTokenizer(uniqueKeyAttribute.Value, ", "); foreach (string token in tokens) table.GetOrCreateUniqueKey(token).AddColumn(column); } }
/// <summary> /// Takes the where condition provided in the mapping attribute and iterpolates the alias. /// </summary> /// <param name="whereSql">The "where" sql statement from the mapping attribute.</param> /// <param name="dialect">The <see cref="Dialect.Dialect"/> to help with rendering the Sql.</param> /// <returns> /// A well formed "where" sql statement for the <see cref="Dialect.Dialect"/>. /// </returns> public static string RenderWhereStringTemplate( string whereSql, Dialect.Dialect dialect ) { //TODO: make this a bit nicer. StringTokenizer tokens = new StringTokenizer( whereSql, delimiters, true ); StringBuilder result = new StringBuilder( whereSql.Length + 10 ); bool quoted = false; bool afterFrom = false; bool afterFromTable = false; IEnumerator tokensEnum = tokens.GetEnumerator(); bool hasMore = tokensEnum.MoveNext(); string nextToken = hasMore ? ( string ) tokensEnum.Current : null; while( hasMore ) { string token = nextToken; hasMore = tokensEnum.MoveNext(); nextToken = hasMore ? ( string ) tokensEnum.Current : null; // the begin or end "'" has been found if( "'".Equals( token ) ) { quoted = !quoted; } if( quoted || char.IsWhiteSpace( token[ 0 ] ) ) { result.Append( token ); } else { bool isIdentifier = token[ 0 ] == '`' || ( // allow any identifier quoted with backtick Char.IsLetter( token[ 0 ] ) && // only recognizes identifiers beginning with a letter !Keywords.Contains( token.ToLower( System.Globalization.CultureInfo.InvariantCulture ) ) && token.IndexOf( '.' ) < 0 ); if( afterFrom ) { result.Append( token ); afterFrom = false; afterFromTable = true; } else if( afterFromTable ) { afterFromTable = false; result.Append( token ); } else if( isIdentifier && ( nextToken == null || !nextToken.Equals( "(" ) ) ) // not a function call { result.Append( Placeholder ) .Append( StringHelper.Dot ) .Append( Quote( token, dialect ) ); } else { if( "from".Equals( token.ToLower( System.Globalization.CultureInfo.InvariantCulture ) ) ) { afterFrom = true; } result.Append( token ); } } } return result.ToString(); }
public StringTokenizerEnumerator(StringTokenizer stok) { _stokenizer = stok; }
/// <summary> /// Splits the String using the StringTokenizer. /// </summary> /// <param name="separators">separators for the tokens of the list</param> /// <param name="list">the string that will be broken into tokens</param> /// <param name="include">true to include the separators in the tokens.</param> /// <returns></returns> /// <remarks> /// This is more powerful than Split because you have the option of including or /// not including the separators in the tokens. /// </remarks> public static string[] Split(string separators, string list, bool include) { var tokens = new StringTokenizer(list, separators, include); return(tokens.ToArray()); }
protected SqlString ExpandDynamicFilterParameters(SqlString sqlString, ICollection<IParameterSpecification> parameterSpecs, ISessionImplementor session) { var enabledFilters = session.EnabledFilters; if (enabledFilters.Count == 0 || sqlString.ToString().IndexOf(ParserHelper.HqlVariablePrefix) < 0) { return sqlString; } Dialect.Dialect dialect = session.Factory.Dialect; string symbols = ParserHelper.HqlSeparators + dialect.OpenQuote + dialect.CloseQuote; var originSql = sqlString.Compact(); var result = new SqlStringBuilder(); foreach (var sqlPart in originSql.Parts) { var parameter = sqlPart as Parameter; if (parameter != null) { result.Add(parameter); continue; } var sqlFragment = sqlPart.ToString(); var tokens = new StringTokenizer(sqlFragment, symbols, true); foreach (string token in tokens) { if (token.StartsWith(ParserHelper.HqlVariablePrefix)) { string filterParameterName = token.Substring(1); string[] parts = StringHelper.ParseFilterParameterName(filterParameterName); string filterName = parts[0]; string parameterName = parts[1]; var filter = (FilterImpl)enabledFilters[filterName]; object value = filter.GetParameter(parameterName); IType type = filter.FilterDefinition.GetParameterType(parameterName); int parameterColumnSpan = type.GetColumnSpan(session.Factory); var collectionValue = value as ICollection; int? collectionSpan = null; // Add query chunk string typeBindFragment = string.Join(", ", Enumerable.Repeat("?", parameterColumnSpan).ToArray()); string bindFragment; if (collectionValue != null && !type.ReturnedClass.IsArray) { collectionSpan = collectionValue.Count; bindFragment = string.Join(", ", Enumerable.Repeat(typeBindFragment, collectionValue.Count).ToArray()); } else { bindFragment = typeBindFragment; } // dynamic-filter parameter tracking var filterParameterFragment = SqlString.Parse(bindFragment); var dynamicFilterParameterSpecification = new DynamicFilterParameterSpecification(filterName, parameterName, type, collectionSpan); var parameters = filterParameterFragment.GetParameters().ToArray(); var sqlParameterPos = 0; var paramTrackers = dynamicFilterParameterSpecification.GetIdsForBackTrack(session.Factory); foreach (var paramTracker in paramTrackers) { parameters[sqlParameterPos++].BackTrack = paramTracker; } parameterSpecs.Add(dynamicFilterParameterSpecification); result.Add(filterParameterFragment); } else { result.Add(token); } } } return result.ToSqlString().Compact(); }
private string Replace(string message, object entity) { var tokens = new StringTokenizer(message, "#${}", true); var buf = new StringBuilder(100); var escaped = false; var el = false; var isMember = false; IEnumerator ie = tokens.GetEnumerator(); while (ie.MoveNext()) { string token = (string) ie.Current; if (!escaped && "#".Equals(token)) { el = true; } if(!el && ("$".Equals(token))) { isMember = true; } else if("}".Equals(token) && isMember) { isMember = false; } if (!el && "{".Equals(token)) { escaped = true; } else if (escaped && "}".Equals(token)) { escaped = false; } else if (!escaped) { if ("{".Equals(token)) { el = false; } if(!"$".Equals(token)) buf.Append(token); } else if(!isMember) { object variable; if (attributeParameters.TryGetValue(token.ToLowerInvariant(), out variable)) { buf.Append(variable); } else { string _string = null; try { _string = messageBundle != null ? messageBundle.GetString(token, culture) : null; } catch (MissingManifestResourceException) { //give a second chance with the default resource bundle } if (_string == null) { _string = defaultMessageBundle.GetString(token, culture); // in this case we don't catch the MissingManifestResourceException because // we are sure that we DefaultValidatorMessages.resx is an embedded resource } if (_string == null) { buf.Append('{').Append(token).Append('}'); } else { buf.Append(Replace(_string,entity)); } } } else { ReplaceValue(buf, entity, token); } } return buf.ToString(); }
public static string RenderOrderByStringTemplate(string sqlOrderByString, Dialect.Dialect dialect, SQLFunctionRegistry functionRegistry) { //TODO: make this a bit nicer string symbols = new StringBuilder() .Append("=><!+-*/()',|&`") .Append(ParserHelper.Whitespace) .Append(dialect.OpenQuote) .Append(dialect.CloseQuote) .ToString(); StringTokenizer tokens = new StringTokenizer(sqlOrderByString, symbols, true); StringBuilder result = new StringBuilder(); bool quoted = false; bool quotedIdentifier = false; IEnumerator<string> tokensEnum = tokens.GetEnumerator(); bool hasMore = tokensEnum.MoveNext(); string nextToken = hasMore ? tokensEnum.Current : null; while (hasMore) { string token = nextToken; string lcToken = token.ToLowerInvariant(); hasMore = tokensEnum.MoveNext(); nextToken = hasMore ? tokensEnum.Current : null; bool isQuoteCharacter = false; if (!quotedIdentifier && "'".Equals(token)) { quoted = !quoted; isQuoteCharacter = true; } if (!quoted) { bool isOpenQuote; if ("`".Equals(token)) { isOpenQuote = !quotedIdentifier; token = lcToken = isOpenQuote ? dialect.OpenQuote.ToString() : dialect.CloseQuote.ToString(); quotedIdentifier = isOpenQuote; isQuoteCharacter = true; } else if (!quotedIdentifier && (dialect.OpenQuote == token[0])) { isOpenQuote = true; quotedIdentifier = true; isQuoteCharacter = true; } else if (quotedIdentifier && (dialect.CloseQuote == token[0])) { quotedIdentifier = false; isQuoteCharacter = true; isOpenQuote = false; } else { isOpenQuote = false; } if (isOpenQuote) { result.Append(Placeholder).Append('.'); } } bool quotedOrWhitespace = quoted || quotedIdentifier || isQuoteCharacter || char.IsWhiteSpace(token[0]); if (quotedOrWhitespace) { result.Append(token); } else if ( IsIdentifier(token, dialect) && !IsFunctionOrKeyword(lcToken, nextToken, dialect, functionRegistry) ) { result.Append(Placeholder) .Append('.') .Append(token); } else { result.Append(token); } } return result.ToString(); }
private ICriteriaInfoProvider GetPathInfo(string path) { StringTokenizer tokens = new StringTokenizer(path, ".", false); string componentPath = string.Empty; // start with the 'rootProvider' ICriteriaInfoProvider provider; if (nameCriteriaInfoMap.TryGetValue(rootEntityName, out provider) == false) throw new ArgumentException("Could not find ICriteriaInfoProvider for: " + path); foreach (string token in tokens) { componentPath += token; logger.DebugFormat("searching for {0}", componentPath); IType type = provider.GetType(componentPath); if (type.IsAssociationType) { // CollectionTypes are always also AssociationTypes - but there's not always an associated entity... IAssociationType atype = (IAssociationType)type; CollectionType ctype = type.IsCollectionType ? (CollectionType)type : null; IType elementType = (ctype != null) ? ctype.GetElementType(sessionFactory) : null; // is the association a collection of components or value-types? (i.e a colloction of valued types?) if (ctype != null && elementType.IsComponentType) { provider = new ComponentCollectionCriteriaInfoProvider(helper.GetCollectionPersister(ctype.Role)); } else if (ctype != null && !elementType.IsEntityType) { provider = new ScalarCollectionCriteriaInfoProvider(helper, ctype.Role); } else { provider = new EntityCriteriaInfoProvider((NHibernate_Persister_Entity.IQueryable)sessionFactory.GetEntityPersister( atype.GetAssociatedEntityName( sessionFactory) )); } componentPath = string.Empty; } else if (type.IsComponentType) { componentPath += '.'; } else { throw new QueryException("not an association: " + componentPath); } } logger.DebugFormat("returning entity name={0} for path={1} class={2}", provider.Name, path, provider.GetType().Name); return provider; }
private IActor ResolveArgument(IActor resolvedActor, String expression, int index) { String argument = null; String whiteSpace = " ".Substring(0, index); String[] parameters = null; int argumentEndIndex = expression.IndexOf("->", index); if (argumentEndIndex == -1) { argumentEndIndex = expression.Length; } int parametersStartIndex = expression.IndexOf("(", index); int parametersEndIndex = -1; if ((parametersStartIndex != -1) && (parametersStartIndex < argumentEndIndex)) { argument = expression.Substring(index, (parametersStartIndex) - (index)).Trim(); parametersEndIndex = expression.IndexOf(")", parametersStartIndex + 1); if (parametersEndIndex > argumentEndIndex) { throw new SystemException("can't resolve assigner expression : couldn't find closing bracket for bracket on index '" + parametersStartIndex + "' in expression '" + expression + "'"); } // the next exception happens when a parameter contains a right bracket. String shouldBewhiteSpace = expression.Substring(parametersEndIndex + 1, (argumentEndIndex) - (parametersEndIndex + 1)); if (!"".Equals(shouldBewhiteSpace.Trim())) { throw new SystemException("can't resolve assigner expression : only whitespace allowed between closing bracket of the parameterlist of an argument and the end of the argument : closing bracket position '" + parametersEndIndex + "' in expression '" + expression + "'"); } String parametersText = expression.Substring(parametersStartIndex + 1, (parametersEndIndex) - (parametersStartIndex + 1)); ArrayList parameterList = new ArrayList(); StringTokenizer tokenizer = new StringTokenizer(parametersText, ","); IEnumerator tokenEnum = tokenizer.GetEnumerator(); while (tokenEnum.MoveNext()) { parameterList.Add(tokenEnum.Current.ToString().Trim()); } if (parameterList.Count > 0) { parameters = new String[parameterList.Count]; parameters = (String[])parameterList.ToArray(typeof(String)); } else { parameters = new String[0]; } } else { argument = expression.Substring(index, (argumentEndIndex) - (index)).Trim(); parameters = new String[0]; } if ("".Equals(argument)) { throw new SystemException("can't resolve assigner expression : can't resolve empty argument on index '" + index + "' for expression '" + expression + "'"); } String methodName = "ResolveArgument" + argument.Substring(0, 1).ToUpper() + argument.Substring(1); try { MethodInfo method = this.GetType().GetMethod(methodName, (Type[])RESOLVE_METHOD_ARGUMENT_TYPES); Object[] args = new Object[] { resolvedActor, parameters }; resolvedActor = (IActor)method.Invoke(this, (Object[])args); } catch (Exception t) { throw new SystemException("can't resolve assigner expression : couldn't resolve argument '" + argument + "' : " + t.Message, t); } if (argumentEndIndex != expression.Length) { if (argumentEndIndex < expression.Length) { argumentEndIndex = expression.IndexOf("->", argumentEndIndex) + 2; } resolvedActor = ResolveArgument(resolvedActor, expression, argumentEndIndex); } return resolvedActor; }
private void DoPathExpression(string token, QueryTranslator q) { Preprocess(token, q); StringTokenizer tokens = new StringTokenizer(token, ".", true); pathExpressionParser.Start(q); foreach (string tok in tokens) { pathExpressionParser.Token(tok, q); } pathExpressionParser.End(q); if (pathExpressionParser.IsCollectionValued) { OpenExpression(q, string.Empty); AppendToken(q, pathExpressionParser.GetCollectionSubquery(q.EnabledFilters)); CloseExpression(q, string.Empty); // this is ugly here, but needed because its a subquery q.AddQuerySpaces(q.GetCollectionPersister(pathExpressionParser.CollectionRole).CollectionSpaces); } else { if (pathExpressionParser.IsExpectingCollectionIndex) { expectingIndex++; } else { AddJoin(pathExpressionParser.WhereJoin, q); AppendToken(q, pathExpressionParser.WhereColumn); } } }
public void OnlyDelimitersWithoutDelimiters() { string s = " .,,,"; StringTokenizer st = new StringTokenizer(s, " ,.", false); IEnumerator enumerator = st.GetEnumerator(); Assert.AreEqual(false, enumerator.MoveNext(), "Still thinking there are more tokens"); }
/// <summary> /// Splits the String using the StringTokenizer. /// </summary> /// <param name="separators">separators for the tokens of the list</param> /// <param name="list">the string that will be broken into tokens</param> /// <param name="include">true to include the separators in the tokens.</param> /// <returns></returns> /// <remarks> /// This is more powerful than Split because you have the option of including or /// not including the separators in the tokens. /// </remarks> public static string[] Split(string separators, string list, bool include) { var tokens = new StringTokenizer(list, separators, include); return tokens.ToArray(); }
public void OnlyDelimitersWithDelimiters() { string s = " .,,,"; StringTokenizer st = new StringTokenizer(s, " ,.", true); IEnumerator enumerator = st.GetEnumerator(); enumerator.MoveNext(); Assert.AreEqual(" ", (string) enumerator.Current, "Can't get first delimiter"); enumerator.MoveNext(); Assert.AreEqual(".", (string) enumerator.Current, "Can't get second delimiter"); enumerator.MoveNext(); Assert.AreEqual(",", (string) enumerator.Current, "Can't get third delimiter"); enumerator.MoveNext(); Assert.AreEqual(",", (string) enumerator.Current, "Can't get fourth delimiter"); enumerator.MoveNext(); Assert.AreEqual(",", (string) enumerator.Current, "Can't get fifth delimiter"); Assert.AreEqual(false, enumerator.MoveNext(), "Still thinking there are more tokens"); }
public void ProcessFilters(SqlString sql, ISessionImplementor session) { filteredParameterValues = new List<object>(); filteredParameterTypes = new List<IType>(); filteredParameterLocations = new List<int>(); if (session.EnabledFilters.Count == 0 || sql.ToString().IndexOf(ParserHelper.HqlVariablePrefix) < 0) { processedSQL = sql.Copy(); return; } Dialect.Dialect dialect = session.Factory.Dialect; string symbols = ParserHelper.HqlSeparators + dialect.OpenQuote + dialect.CloseQuote; var result = new SqlStringBuilder(); int originalParameterIndex = 0; // keep track of the positional parameter int newParameterIndex = 0; _adjustedParameterLocations = new Dictionary<int, int>(); foreach (var part in sql.Parts) { if (part is Parameter) { result.AddParameter(); // (?) can be a position parameter or a named parameter (already substituted by (?), // but only the positional parameters are available at this point. Adding them in the // order of appearance is best that can be done at this point of time, but if they // are mixed with named parameters, the order is still wrong, because values and // types for the named parameters are added later to the end of the list. // see test fixture NH-1098 _adjustedParameterLocations[originalParameterIndex] = newParameterIndex; originalParameterIndex++; newParameterIndex++; continue; } var tokenizer = new StringTokenizer((string) part, symbols, true); foreach (var token in tokenizer) { if (token.StartsWith(ParserHelper.HqlVariablePrefix)) { string filterParameterName = token.Substring(1); object value = session.GetFilterParameterValue(filterParameterName); IType type = session.GetFilterParameterType(filterParameterName); // If the value is not a value of the type but a collection of values... if (value != null && !type.ReturnedClass.IsAssignableFrom(value.GetType()) && // Added to fix NH-882 typeof (ICollection).IsAssignableFrom(value.GetType())) { var coll = (ICollection) value; int i = 0; foreach (var elementValue in coll) { i++; int span = type.GetColumnSpan(session.Factory); if (span > 0) { result.AddParameter(); filteredParameterTypes.Add(type); filteredParameterValues.Add(elementValue); filteredParameterLocations.Add(newParameterIndex); newParameterIndex++; if (i < coll.Count) { result.Add(", "); } } } } else { int span = type.GetColumnSpan(session.Factory); if (span > 0) { result.AddParameter(); filteredParameterTypes.Add(type); filteredParameterValues.Add(value); filteredParameterLocations.Add(newParameterIndex); newParameterIndex++; } } } else { result.Add(token); } } } processedSQL = result.ToSqlString(); }
private void AddColumnsFromList(HbmId idSchema, SimpleValue id) { int count = 0; foreach (HbmColumn columnSchema in idSchema.column ?? new HbmColumn[0]) { Column column = CreateColumn(columnSchema, id, count++); column.Name = mappings.NamingStrategy.ColumnName(columnSchema.name); if (id.Table != null) id.Table.AddColumn(column); //table=null -> an association, fill it in later id.AddColumn(column); if (columnSchema.index != null && id.Table != null) { StringTokenizer tokens = new StringTokenizer(columnSchema.index, ", "); foreach (string token in tokens) id.Table.GetOrCreateIndex(token).AddColumn(column); } if (columnSchema.uniquekey != null && id.Table != null) { StringTokenizer tokens = new StringTokenizer(columnSchema.uniquekey, ", "); foreach (string token in tokens) id.Table.GetOrCreateUniqueKey(token).AddColumn(column); } } }
/// <summary> /// Format an SQL statement using simple rules /// </summary> /// <param name="sql">The string containing the sql to format.</param> /// <returns>A string that contains formatted sql.</returns> /// <remarks> /// The simple rules to used when formatting are: /// <list type="number"> /// <item> /// <description>Insert a newline after each comma</description> /// </item> /// <item> /// <description>Indent three spaces after each inserted newline</description> /// </item> /// <item> /// <description> /// If the statement contains single/double quotes return unchanged because /// it is too complex and could be broken by simple formatting. /// </description> /// </item> /// </list> /// </remarks> private static string Format(string sql) { if (sql.IndexOf("\"") > 0 || sql.IndexOf("'") > 0) { return sql; } string formatted; if (StringHelper.StartsWithCaseInsensitive(sql, "create table")) { StringBuilder result = new StringBuilder(60); StringTokenizer tokens = new StringTokenizer(sql, "(,)", true); int depth = 0; foreach (string tok in tokens) { if (StringHelper.ClosedParen.Equals(tok)) { depth--; if (depth == 0) { result.Append("\n"); } } result.Append(tok); if (StringHelper.Comma.Equals(tok) && depth == 1) { result.Append("\n "); } if (StringHelper.OpenParen.Equals(tok)) { depth++; if (depth == 1) { result.Append("\n "); } } } formatted = result.ToString(); } else { formatted = sql; } return formatted; }
private IJoinable GetPathJoinable(string path) { IJoinable last = (IJoinable)Factory.GetEntityPersister(rootEntityName); IPropertyMapping lastEntity = (IPropertyMapping)last; string componentPath = ""; StringTokenizer tokens = new StringTokenizer(path, ".", false); foreach (string token in tokens) { componentPath += token; IType type = lastEntity.ToType(componentPath); if (type.IsAssociationType) { IAssociationType atype = (IAssociationType)type; last = atype.GetAssociatedJoinable(Factory); lastEntity = (IPropertyMapping)Factory.GetEntityPersister(atype.GetAssociatedEntityName(Factory)); componentPath = ""; } else if (type.IsComponentType) { componentPath += '.'; } else { throw new QueryException("not an association: " + componentPath); } } return last; }
private Persister.Entity.IJoinable GetPathJoinable(string path) { NHibernate_Persister_Entity.IJoinable last = (NHibernate_Persister_Entity.IJoinable)Factory.GetEntityPersister(rootEntityName); NHibernate_Persister_Entity.IPropertyMapping lastEntity = (NHibernate_Persister_Entity.IPropertyMapping)last; string componentPath = ""; StringTokenizer tokens = new StringTokenizer(path, ".", false); foreach (string token in tokens) { componentPath += token; IType type = lastEntity.ToType(componentPath); if (type.IsAssociationType) { if(type.IsCollectionType) { // ignore joinables for composite collections var collectionType = (CollectionType)type; var persister = Factory.GetCollectionPersister(collectionType.Role); if(persister.ElementType.IsEntityType==false) return null; } IAssociationType atype = (IAssociationType)type; last = atype.GetAssociatedJoinable(Factory); lastEntity = (NHibernate_Persister_Entity.IPropertyMapping)Factory.GetEntityPersister(atype.GetAssociatedEntityName(Factory)); componentPath = ""; } else if (type.IsComponentType) { componentPath += '.'; } else { throw new QueryException("not an association: " + componentPath); } } return last; }
private string GetPathEntityName(string path) { IQueryable persister = (IQueryable)sessionFactory.GetEntityPersister(rootEntityName); StringTokenizer tokens = new StringTokenizer(path, ".", false); string componentPath = ""; foreach (string token in tokens) { componentPath += token; IType type = persister.ToType(componentPath); if (type.IsAssociationType) { IAssociationType atype = (IAssociationType)type; persister = (IQueryable)sessionFactory.GetEntityPersister(atype.GetAssociatedEntityName(sessionFactory)); componentPath = ""; } else if (type.IsComponentType) { componentPath += '.'; } else { throw new QueryException("not an association: " + componentPath); } } return persister.EntityName; }
public static string RenderWhereStringTemplate(string sqlWhereString, string placeholder, Dialect.Dialect dialect, SQLFunctionRegistry functionRegistry) { //TODO: make this a bit nicer string symbols = new StringBuilder() .Append("=><!+-*/()',|&`") .Append(ParserHelper.Whitespace) .Append(dialect.OpenQuote) .Append(dialect.CloseQuote) .ToString(); StringTokenizer tokens = new StringTokenizer(sqlWhereString, symbols, true); StringBuilder result = new StringBuilder(); bool quoted = false; bool quotedIdentifier = false; bool beforeTable = false; bool inFromClause = false; bool afterFromTable = false; IEnumerator tokensEnum = tokens.GetEnumerator(); bool hasMore = tokensEnum.MoveNext(); string nextToken = hasMore ? (string) tokensEnum.Current : null; while (hasMore) { string token = nextToken; string lcToken = token.ToLower(CultureInfo.InvariantCulture); hasMore = tokensEnum.MoveNext(); nextToken = hasMore ? (string) tokensEnum.Current : null; bool isQuoteCharacter = false; if (!quotedIdentifier && "'".Equals(token)) { quoted = !quoted; isQuoteCharacter = true; } if (!quoted) { bool isOpenQuote; if ("`".Equals(token)) { isOpenQuote = !quotedIdentifier; token = lcToken = isOpenQuote ? dialect.OpenQuote.ToString() : dialect.CloseQuote.ToString(); quotedIdentifier = isOpenQuote; isQuoteCharacter = true; } else if (!quotedIdentifier && (dialect.OpenQuote == token[0])) { isOpenQuote = true; quotedIdentifier = true; isQuoteCharacter = true; } else if (quotedIdentifier && (dialect.CloseQuote == token[0])) { quotedIdentifier = false; isQuoteCharacter = true; isOpenQuote = false; } else { isOpenQuote = false; } if (isOpenQuote) { result.Append(placeholder).Append('.'); } } bool quotedOrWhitespace = quoted || quotedIdentifier || isQuoteCharacter || char.IsWhiteSpace(token[0]); if (quotedOrWhitespace) { result.Append(token); } else if (beforeTable) { result.Append(token); beforeTable = false; afterFromTable = true; } else if (afterFromTable) { if (!"as".Equals(lcToken)) afterFromTable = false; result.Append(token); } else if (IsNamedParameter(token)) { result.Append(token); } else if ( IsIdentifier(token, dialect) && !IsFunctionOrKeyword(lcToken, nextToken, dialect, functionRegistry) ) { result.Append(placeholder) .Append('.') .Append(token); } else { if (BeforeTableKeywords.Contains(lcToken)) { beforeTable = true; inFromClause = true; } else if (inFromClause && ",".Equals(lcToken)) { beforeTable = true; } result.Append(token); } if ( //Yuck: inFromClause && Keywords.Contains(lcToken) && //"as" is not in Keywords !BeforeTableKeywords.Contains(lcToken) ) { inFromClause = false; } } return result.ToString(); }
public static void ProcessDynamicFilterParameters( SqlString sqlFragment, IParameterContainer container, HqlSqlWalker walker) { if ( walker.EnabledFilters.Count == 0 && ( ! HasDynamicFilterParam( sqlFragment ) ) && ( ! ( HasCollectionFilterParam( sqlFragment ) ) ) ) { return; } Dialect.Dialect dialect = walker.SessionFactoryHelper.Factory.Dialect; string symbols = new StringBuilder().Append( ParserHelper.HqlSeparators ) .Append( dialect.OpenQuote) .Append( dialect.CloseQuote) .ToString(); StringTokenizer tokens = new StringTokenizer( sqlFragment.ToString(), symbols, true ); StringBuilder result = new StringBuilder(); foreach (string token in tokens) { if ( token.StartsWith( ParserHelper.HqlVariablePrefix ) ) { string filterParameterName = token.Substring( 1 ); string[] parts = StringHelper.ParseFilterParameterName( filterParameterName ); FilterImpl filter = ( FilterImpl ) walker.EnabledFilters[parts[0]]; Object value = filter.GetParameter( parts[1] ); IType type = filter.FilterDefinition.GetParameterType( parts[1] ); String typeBindFragment = StringHelper.Join( ",", ArrayHelper.FillArray( "?", type.GetColumnSpan( walker.SessionFactoryHelper.Factory ) ) ); string bindFragment = ( value != null && value is ICollection) ? StringHelper.Join( ",", ArrayHelper.FillArray( typeBindFragment, ( ( ICollection ) value ).Count ) ) : typeBindFragment; //result.Append( bindFragment ); result.Append(token); container.AddEmbeddedParameter( new DynamicFilterParameterSpecification( parts[0], parts[1], type ) ); } else { result.Append( token ); } } container.Text = result.ToString(); }
private Property GetRecursiveProperty(string propertyPath, IEnumerable<Property> iter) { Property property = null; StringTokenizer st = new StringTokenizer(propertyPath, ".", false); try { foreach (string element in st) { if (property == null) { // we are processing the root of the prpertyPath, so we have the following // considerations: // 1) specifically account for identifier properties // 2) specifically account for embedded composite-identifiers // 3) perform a normal property lookup Property identifierProperty = IdentifierProperty; if (identifierProperty != null && identifierProperty.Name.Equals(element)) { // we have a mapped identifier property and the root of // the incoming property path matched that identifier // property property = identifierProperty; } else if (identifierProperty == null && Identifier != null && typeof(Component).IsInstanceOfType(Identifier)) { // we have an embedded composite identifier try { identifierProperty = GetProperty(element, ((Component)Identifier).PropertyIterator); if (identifierProperty != null) { // the root of the incoming property path matched one // of the embedded composite identifier properties property = identifierProperty; } } catch (MappingException) { // ignore it... } } if (property == null) { property = GetProperty(element, iter); } } else { //flat recursive algorithm property = ((Component) property.Value).GetProperty(element); } } } catch (MappingException) { throw new MappingException("property [" + propertyPath + "] not found on entity [" + EntityName + "]"); } return property; }
private Property GetRecursiveProperty(string propertyPath, ICollection iter) { Property property = null; StringTokenizer st = new StringTokenizer(propertyPath, ".", false); try { foreach (string element in st) { if (property == null) { property = GetProperty(element, iter); } else { //flat recursive algorithm property = ((Component) property.Value).GetProperty(element); } } } catch (MappingException e) { throw new MappingException( "property not found: " + propertyPath + " in entity: " + Name, e ); } return property; }
/// <summary> /// Splits the String using the StringTokenizer. /// </summary> /// <param name="separators">separators for the tokens of the list</param> /// <param name="list">the string that will be broken into tokens</param> /// <param name="include">true to include the separators in the tokens.</param> /// <returns></returns> /// <remarks> /// This is more powerful than Split because you have the option of including or /// not including the separators in the tokens. /// </remarks> public static string[] Split(string separators, string list, bool include) { StringTokenizer tokens = new StringTokenizer(list, separators, include); ArrayList results = new ArrayList(); foreach (string token in tokens) { results.Add(token); } return (string[])results.ToArray(typeof(string)); }
internal static SqlString ExpandDynamicFilterParameters(SqlString sqlString, ICollection <IParameterSpecification> parameterSpecs, ISessionImplementor session) { var enabledFilters = session.EnabledFilters; if (enabledFilters.Count == 0 || !ParserHelper.HasHqlVariable(sqlString)) { return(sqlString); } Dialect.Dialect dialect = session.Factory.Dialect; string symbols = ParserHelper.HqlSeparators + dialect.OpenQuote + dialect.CloseQuote; var result = new SqlStringBuilder(); foreach (var sqlPart in sqlString) { var parameter = sqlPart as Parameter; if (parameter != null) { result.Add(parameter); continue; } var sqlFragment = sqlPart.ToString(); var tokens = new StringTokenizer(sqlFragment, symbols, true); foreach (string token in tokens) { if (ParserHelper.IsHqlVariable(token)) { string filterParameterName = token.Substring(1); string[] parts = StringHelper.ParseFilterParameterName(filterParameterName); string filterName = parts[0]; string parameterName = parts[1]; var filter = (FilterImpl)enabledFilters[filterName]; int? collectionSpan = filter.GetParameterSpan(parameterName); IType type = filter.FilterDefinition.GetParameterType(parameterName); int parameterColumnSpan = type.GetColumnSpan(session.Factory); // Add query chunk string typeBindFragment = string.Join(", ", Enumerable.Repeat("?", parameterColumnSpan)); string bindFragment; if (collectionSpan.HasValue && !type.ReturnedClass.IsArray) { bindFragment = string.Join(", ", Enumerable.Repeat(typeBindFragment, collectionSpan.Value)); } else { bindFragment = typeBindFragment; } // dynamic-filter parameter tracking var filterParameterFragment = SqlString.Parse(bindFragment); var dynamicFilterParameterSpecification = new DynamicFilterParameterSpecification(filterName, parameterName, type, collectionSpan); var parameters = filterParameterFragment.GetParameters().ToArray(); var sqlParameterPos = 0; var paramTrackers = dynamicFilterParameterSpecification.GetIdsForBackTrack(session.Factory); foreach (var paramTracker in paramTrackers) { parameters[sqlParameterPos++].BackTrack = paramTracker; } if (parameterSpecs.OfType <DynamicFilterParameterSpecification>().Any(p => p.FilterParameterFullName == dynamicFilterParameterSpecification.FilterParameterFullName)) { var alreadyExistingParamSpecs = parameterSpecs.OfType <DynamicFilterParameterSpecification>().Where(p => p.FilterParameterFullName == dynamicFilterParameterSpecification.FilterParameterFullName).ToList(); foreach (var alreadyExistingParamSpec in alreadyExistingParamSpecs) { parameterSpecs.Remove(alreadyExistingParamSpec); } } parameterSpecs.Add(dynamicFilterParameterSpecification); result.Add(filterParameterFragment); } else { result.Add(token); } } } return(result.ToSqlString()); }