public void End(QueryTranslator q)
{
if (parenCount > 0 || funcStack.HasFunctions)
{
throw new QueryException("close paren missed in SELECT");
}
}
public string GetSqlWithClassicParser(string query)
{
var qt = new NHibernate.Hql.Classic.QueryTranslator(null, query, emptyfilters, sessions);
qt.Compile(new Dictionary <string, string>(), false);
return(qt.SQLString);
}
protected override void AppendToken(QueryTranslator q, string token)
{
// 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.AppendHavingToken(new SqlString(token));
}
public void Start(QueryTranslator q)
{
readyForAliasOrExpression = true;
first = true;
afterNew = false;
holderClass = null;
parenCount = 0;
funcStack = new FunctionStack(q.Factory);
}
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 string ContinueFromManyToMany(System.Type clazz, string[] joinColumns, QueryTranslator q)
{
Start(q);
continuation = true;
currentName = q.CreateNameFor(clazz);
q.AddType(currentName, clazz);
IQueryable classPersister = q.GetPersister(clazz);
AddJoin(currentName, TypeFactory.ManyToOne(clazz), joinColumns);
currentPropertyMapping = classPersister;
return currentName;
}
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);
}
}
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);
}
}
public override void End(QueryTranslator q)
{
if (!IsCollectionValued)
{
IType type = PropertyType;
if (type.IsEntityType)
{
// "finish off" the join
Token(".", q);
Token(null, q);
}
else if (type.IsCollectionType)
{
// default to element set if no elements() specified
Token(".", q);
Token(CollectionPropertyNames.Elements, q);
}
}
base.End(q);
}
private void SetType(QueryTranslator q)
{
if (currentProperty == null)
{
type = PropertyMapping.Type;
}
else
{
type = PropertyType;
}
}
private void DereferenceCollection(String propertyName, String role, QueryTranslator q)
{
collectionRole = role;
IQueryableCollection collPersister = q.GetCollectionPersister(role);
string name = q.CreateNameForCollection(role);
AddJoin(name, collPersister.CollectionType);
//if ( collPersister.HasWhere )
//{
// join.AddCondition( collPersister.GetSQLWhereString( name ) );
//}
collectionName = name;
collectionOwnerName = currentName;
currentName = name;
currentProperty = propertyName;
componentPath.Length = 0;
//componentPath = new StringBuilder();
currentPropertyMapping = new CollectionPropertyMapping(collPersister);
}
/// <summary>
///
/// </summary>
/// <param name="propertyName"></param>
/// <param name="propertyType"></param>
/// <param name="q"></param>
/// <remarks>NOTE: we avoid joining to the next table if the named property is just the foreign key value</remarks>
private void DereferenceEntity(string propertyName, EntityType propertyType, QueryTranslator q)
{
//if its "id"
bool isIdShortcut = EntityID.Equals(propertyName) && !propertyType.IsUniqueKeyReference;
//or its the id property name
string idPropertyName;
try
{
idPropertyName = propertyType.GetIdentifierOrUniqueKeyPropertyName(q.Factory);
}
catch (MappingException me)
{
throw new QueryException(me);
}
bool isNamedIdPropertyShortcut = idPropertyName != null && idPropertyName.Equals(propertyName);
if (isIdShortcut || isNamedIdPropertyShortcut)
{
// special shortcut for id properties, skip the join!
// this must only occur at the _end_ of a path expression
DereferenceProperty(propertyName);
}
else
{
string entityClass = propertyType.GetAssociatedEntityName();
string name = q.CreateNameFor(entityClass);
q.AddType(name, entityClass);
//String[] keyColNames = memberPersister.getIdentifierColumnNames();
AddJoin(name, propertyType);
if (propertyType.IsOneToOne)
{
oneToOneOwnerName = currentName;
}
else
{
oneToOneOwnerName = null;
}
ownerAssociationType = propertyType;
currentName = name;
currentProperty = propertyName;
q.AddPathAliasAndJoin(path.ToString(0, path.ToString().LastIndexOf(StringHelper.Dot)), name, joinSequence.Copy());
componentPath.Length = 0;
currentPropertyMapping = q.GetPersister(entityClass);
}
}
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);
}
}
}
}
protected virtual void AppendToken(QueryTranslator q, SqlString token)
{
if (expectingIndex > 0)
{
pathExpressionParser.SetLastCollectionElementIndexValue(token);
}
else
{
q.AppendWhereToken(token);
}
}
/// <summary>
///
/// </summary>
/// <param name="q"></param>
public void AddAssociation(QueryTranslator q)
{
q.AddJoin(Name, joinSequence);
}
/// <summary>
///
/// </summary>
/// <param name="q"></param>
public virtual void End(QueryTranslator q)
{
ignoreInitialJoin = false;
IType propertyType = PropertyType;
if (propertyType != null && propertyType.IsCollectionType)
{
collectionRole = ((CollectionType) propertyType).Role;
collectionName = q.CreateNameForCollection(collectionRole);
PrepareForIndex(q);
}
else
{
columns = CurrentColumns();
SetType(q);
}
//important!!
continuation = false;
}
protected virtual void AppendToken(QueryTranslator q, string token)
{
if (expectingIndex > 0)
{
pathExpressionParser.SetLastCollectionElementIndexValue(new SqlString(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 (!string.IsNullOrEmpty(token))
{
q.AppendWhereToken(new SqlString(token));
}
}
}
/// <summary>
///
/// </summary>
/// <param name="q"></param>
/// <returns></returns>
public string AddFromCollection(QueryTranslator q)
{
IType collectionElementType = PropertyType;
if (collectionElementType == null)
{
throw new QueryException(
string.Format("must specify 'elements' for collection valued property in from clause: {0}", path));
}
if (collectionElementType.IsEntityType)
{
// an association
IQueryableCollection collectionPersister = q.GetCollectionPersister(collectionRole);
IQueryable entityPersister = (IQueryable) collectionPersister.ElementPersister;
string clazz = entityPersister.EntityName;
string elementName;
if (collectionPersister.IsOneToMany)
{
elementName = collectionName;
// allow index() function
q.DecoratePropertyMapping(elementName, collectionPersister);
}
else
{
// many to many
q.AddCollection(collectionName, collectionRole);
elementName = q.CreateNameFor(clazz);
AddJoin(elementName, (IAssociationType) collectionElementType);
}
q.AddFrom(elementName, clazz, joinSequence);
currentPropertyMapping = new CollectionPropertyMapping(collectionPersister);
return elementName;
}
// collection of values
q.AddFromCollection(collectionName, collectionRole, joinSequence);
return collectionName;
}
/// <summary>
/// Compile a subquery
/// </summary>
/// <param name="superquery"></param>
protected internal void Compile(QueryTranslator superquery)
{
tokenReplacements = superquery.tokenReplacements;
superQuery = superquery;
shallowQuery = true;
enabledFilters = superquery.EnabledFilters;
Compile();
}
public Selector(QueryTranslator outer)
{
this.outer = outer;
}
public ParameterTranslations(QueryTranslator queryTraslator)
{
this.queryTraslator = queryTraslator;
}
public string GetSqlWithClassicParser(string query)
{
var qt = new NHibernate.Hql.Classic.QueryTranslator(null, query, emptyfilters, sessions);
qt.Compile(new Dictionary<string, string>(), false);
return qt.SQLString;
}
private void Reset(QueryTranslator q)
{
//join = q.CreateJoinFragment( useThetaStyleJoin );
dotcount = 0;
currentName = null;
currentProperty = null;
collectionName = null;
collectionRole = null;
componentPath.Length = 0;
type = null;
collectionName = null;
columns = null;
expectingCollectionIndex = false;
continuation = false;
currentPropertyMapping = null;
}
/// <summary>
///
/// </summary>
/// <param name="q"></param>
public void Start(QueryTranslator q)
{
if (!continuation)
{
Reset(q);
path.Length = 0;
joinSequence = new JoinSequence(q.Factory).SetUseThetaStyle(useThetaStyleJoin);
}
}
public void End(QueryTranslator q)
{
}
private void PrepareForIndex(QueryTranslator q)
{
IQueryableCollection collPersister = q.GetCollectionPersister(collectionRole);
if (!collPersister.HasIndex)
{
throw new QueryException("unindexed collection before []");
}
string[] indexCols = collPersister.IndexColumnNames;
if (indexCols.Length != 1)
{
throw new QueryException("composite-index appears in []: " + path);
}
JoinSequence fromJoins = new JoinSequence(q.Factory)
.SetUseThetaStyle(useThetaStyleJoin)
.SetRoot(collPersister, collectionName)
.SetNext(joinSequence.Copy());
if (!continuation)
{
AddJoin(collectionName, collPersister.CollectionType);
}
joinSequence.AddCondition(new SqlString(collectionName + '.' + indexCols[0] + " = "));
CollectionElement elem = new CollectionElement();
elem.ElementColumns = collPersister.GetElementColumnNames(collectionName);
elem.Type = collPersister.ElementType;
elem.IsOneToMany = collPersister.IsOneToMany;
elem.Alias = collectionName;
elem.JoinSequence = joinSequence;
collectionElements.Add(elem); //addlast
SetExpectingCollectionIndex();
q.AddCollection(collectionName, collectionRole);
q.AddJoin(collectionName, fromJoins);
}
protected override void AppendToken(QueryTranslator q, SqlString token)
{
q.AppendHavingToken(token);
}
/// <summary>
///
/// </summary>
/// <param name="q"></param>
/// <returns></returns>
public string AddFromAssociation(QueryTranslator q)
{
if (IsCollectionValued)
{
return AddFromCollection(q);
}
q.AddFrom(currentName, joinSequence);
return currentName;
}
private bool ContinuePathExpression(string token, QueryTranslator q)
{
expectingPathContinuation = false;
PathExpressionParser.CollectionElement element = pathExpressionParser.LastCollectionElement();
if (token.StartsWith("."))
{
// the path expression continues after a ]
DoPathExpression(GetElementName(element, q) + token, q); // careful with this!
AddToCurrentJoin(element);
return true; //NOTE: EARLY EXIT!
}
else
{
// the path expression ends at the ]
if (element.ElementColumns.Length != 1)
{
throw new QueryException("path expression ended in composite collection element");
}
AppendToken(q, element.ElementColumns[0]);
AddToCurrentJoin(element);
return false;
}
}
/// <summary>
///
/// </summary>
/// <param name="q"></param>
/// <param name="entityName"></param>
public void Fetch(QueryTranslator q, string entityName)
{
if (IsCollectionValued)
{
q.AddCollectionToFetch(CollectionRole, CollectionName, CollectionOwnerName, entityName);
}
else
{
q.AddEntityToFetch(entityName, oneToOneOwnerName, ownerAssociationType);
}
}
public void Start(QueryTranslator q)
{
}
