/// <summary>
/// Registers Select Project Expression with one Param.
/// </summary>
/// <typeparam name="TSource">Source param type.</typeparam>
/// <typeparam name="TDest">Destanation param type.</typeparam>
/// <typeparam name="TParam">Parameter param type.</typeparam>
/// <param name="selectExpression">Select Projection Expression factory.</param>
public static void Register <TSource, TDest, TParam>(ISelectExpression <TSource, TDest, TParam> selectExpression)
{
if (!RegisterAllIfMultipleMappings(selectExpression))
{
SelectResolverWith1Params.Register(selectExpression);
}
}
public ColumnCollection GetColumns()
{
ColumnCollection columns = new ColumnCollection();
ISqlScript sqlScript = SqlParserService.Parse(_select);
if (sqlScript.Statements != null && sqlScript.Statements.Count > 0)
{
ISqlStatement statement = sqlScript.Statements[0];
if (statement is ISelectStatement)
{
ISelectStatement selectStatement = statement as ISelectStatement;
if (selectStatement.QueryExpression != null && selectStatement.QueryExpression is ISelectExpression)
{
ISelectExpression selectExpression = selectStatement.QueryExpression as ISelectExpression;
for (int i = 0; i < selectExpression.SelectList.Count; i++)
{
SelectColumn selectColumn = selectExpression.SelectList[i];
Column column = _table[selectColumn.Name];
if (column != null)
{
columns.Add(column);
}
}
}
}
}
return(columns);
}
public void SetSelectExpression(ISelectExpression selectExpression)
{
if (selectExpression == null || selectExpression.Alias == null)
{
throw new SemanticException("A ResultVariableRefNode must refer to a non-null alias.");
}
_selectExpression = selectExpression;
}
public void SetSelectExpression(ISelectExpression selectExpression)
{
if (selectExpression == null || selectExpression.Alias == null)
{
throw new SemanticException("A ResultVariableRefNode must refer to a non-null alias.");
}
_selectExpression = selectExpression;
}
/*
* /api/v2/{entity}/{id}?where={where}&select={select}&result={result}&take={take}&skip={skip}&orderBy={orderby}&callback={callback}&filter={filter}
*
* {entity} - entity type name in single case (Userstory, Bug) or plural case (Userstories, Bugs) - see here for the list of available entity types
* {id} - optional entity id. If specified, the response will contain only one item in {items} collection
* {where} - filter expression over collection of entities
* {select} - select projection.
* {result} - final expression, used for aggregations' calculation on root entity.
* {skip}, {take} - paging parameters, how many entities skip and take. If the result contains more entities, the response will have fields "next" or/and "prev" links to another pages.
* {orderBy} - orderings
* {callback} - JSONP callback
* {filter} - a DSL Filter or Simple Filter like on boards. filter and where clauses are combined with and operator.
*
**/
public ApiRequest(string resourceType, FilterExpression filter, ISelectExpression select, int skip, int take, OrderByExpression order)
{
this.ResourceType = resourceType;
this.Filter = filter;
this.Select = select;
this.Skip = skip;
this.Take = take;
this.Order = order;
}
public void SetScalarColumnText(int i)
{
ISelectExpression[] selectExpressions = CollectSelectExpressions();
// Invoke setScalarColumnText on each constructor argument.
for (int j = 0; j < selectExpressions.Length; j++)
{
ISelectExpression selectExpression = selectExpressions[j];
selectExpression.SetScalarColumnText(j);
}
}
protected override void Configure(TQuery request)
{
base.Configure(request);
Select = GetSelectExpression();
// TODO If TQuery == IQueryEntitySingle -> set property Id
// TODO Set property MustExist in sub-class (get/find)
// TODO Then we could define Execute here and choose action based on whether
// Id != null and MustExist == true/false
}
private static void RenderScalarSelects(ISelectExpression[] se, FromClause currentFromClause)
{
if (!currentFromClause.IsSubQuery)
{
for (int i = 0; i < se.Length; i++)
{
ISelectExpression expr = se[i];
expr.SetScalarColumnText(i); // Create SQL_TOKEN nodes for the columns.
}
}
}
private static bool IsReturnableEntity(ISelectExpression selectExpression)
{
FromElement fromElement = selectExpression.FromElement;
bool isFetchOrValueCollection = fromElement != null &&
(fromElement.IsFetch || fromElement.IsCollectionOfValuesOrComponents);
if (isFetchOrValueCollection)
{
return(false);
}
else
{
return(selectExpression.IsReturnableEntity);
}
}
private void RenderNonScalarSelects(ISelectExpression[] selectExpressions, FromClause currentFromClause)
{
ASTAppender appender = new ASTAppender(ASTFactory, this);
int size = selectExpressions.Length;
int nonscalarSize = 0;
for (int i = 0; i < size; i++)
{
if (!selectExpressions[i].IsScalar)
{
nonscalarSize++;
}
}
int j = 0;
for (int i = 0; i < size; i++)
{
if (!selectExpressions[i].IsScalar)
{
ISelectExpression expr = selectExpressions[i];
FromElement fromElement = expr.FromElement;
if (fromElement != null)
{
RenderNonScalarIdentifiers(fromElement, nonscalarSize, j, expr, appender);
j++;
}
}
}
if (!currentFromClause.IsSubQuery)
{
// Generate the property select tokens.
int k = 0;
for (int i = 0; i < size; i++)
{
if (!selectExpressions[i].IsScalar)
{
FromElement fromElement = selectExpressions[i].FromElement;
if (fromElement != null)
{
RenderNonScalarProperties(appender, fromElement, nonscalarSize, k);
k++;
}
}
}
}
}
public void Register <TSource, TDest, TParam1, TParam2>(ISelectExpression <TSource, TDest, TParam1, TParam2> resolver)
{
PairId id = PairId.GetId <TSource, TDest>();
var factory = (Func <TParam1, TParam2, Expression <Func <TSource, TDest> > >)resolver.GetSelectExpression;
lock (_sync)
{
if (_expressionFactories.ContainsKey(id))
{
_expressionFactories[id] = factory;
TryRemoveExpressions <TParam1, TParam2>(id);
}
else
{
_expressionFactories.Add(id, factory);
}
}
}
private void RenderNonScalarIdentifiers(FromElement fromElement, int nonscalarSize, int j, ISelectExpression expr, ASTAppender appender)
{
string text = fromElement.RenderIdentifierSelect(nonscalarSize, j);
if (!fromElement.FromClause.IsSubQuery)
{
if (!_scalarSelect && !Walker.IsShallowQuery)
{
//TODO: is this a bit ugly?
expr.Text = text;
}
else
{
appender.Append(HqlSqlWalker.SQL_TOKEN, text, false);
}
}
}
private void RenderNonScalarSelects(ISelectExpression[] selectExpressions, FromClause currentFromClause)
{
ASTAppender appender = new ASTAppender(ASTFactory, this);
int size = selectExpressions.Length;
int nonscalarSize = 0;
for (int i = 0; i < size; i++)
{
if (!selectExpressions[i].IsScalar)
{
nonscalarSize++;
}
}
int j = 0;
for (int i = 0; i < size; i++)
{
if (!selectExpressions[i].IsScalar)
{
ISelectExpression expr = selectExpressions[i];
FromElement fromElement = expr.FromElement;
if (fromElement != null)
{
RenderNonScalarIdentifiers(fromElement, nonscalarSize, j, expr, appender);
j++;
}
}
}
if (!currentFromClause.IsSubQuery)
{
// Generate the property select tokens.
int k = 0;
for (int i = 0; i < size; i++)
{
if (!selectExpressions[i].IsScalar)
{
FromElement fromElement = selectExpressions[i].FromElement;
if (fromElement != null)
{
RenderNonScalarProperties(appender, fromElement, nonscalarSize, k);
k++;
}
}
}
}
}
private void InitAliases(ISelectExpression[] selectExpressions)
{
if (_constructorNode == null)
{
_aliases = new String[selectExpressions.Length];
for (int i = 0; i < selectExpressions.Length; i++)
{
string alias = selectExpressions[i].Alias;
_aliases[i] = alias ?? i.ToString();
}
}
else
{
_aliases = _constructorNode.GetAliases();
}
}
private static bool IsReturnableEntity(ISelectExpression selectExpression)
{
FromElement fromElement = selectExpression.FromElement;
bool isFetchOrValueCollection = fromElement != null &&
(fromElement.IsFetch || fromElement.IsCollectionOfValuesOrComponents);
if (isFetchOrValueCollection)
{
return false;
}
else
{
return selectExpression.IsReturnableEntity;
}
}
private bool TryGetOrActivate <TSource, TDest, TParam1, TParam2>(TParam1 param1, TParam2 param2, Func <ISelectExpression <TSource, TDest, TParam1, TParam2> > activator, out Expression <Func <TSource, TDest> > expression)
{
PairId id = PairId.GetId <TSource, TDest>();
Dictionary <PairId, LambdaExpression> expressions = GetOrAddParamExpressionsDictionary(param1, param2, add: false);
Delegate factoryDelegate;
LambdaExpression lambdaExpression;
if (expressions != null && expressions.TryGetValue(id, out lambdaExpression))
{
expression = (Expression <Func <TSource, TDest> >)lambdaExpression;
return(true);
}
else if (_dynamicExpressionFactories.TryGetValue(id, out factoryDelegate))
{
expression = ((Func <TParam1, TParam2, Expression <Func <TSource, TDest> > >)factoryDelegate)(param1, param2);
return(true);
}
lock (_sync)
{
expressions = expressions ?? GetOrAddParamExpressionsDictionary(param1, param2, add: true);
if (expressions.TryGetValue(id, out lambdaExpression))
{
expression = (Expression <Func <TSource, TDest> >)lambdaExpression;
return(true);
}
Func <TParam1, TParam2, Expression <Func <TSource, TDest> > > factory;
if (_expressionFactories.TryGetValue(id, out factoryDelegate))
{
factory = (Func <TParam1, TParam2, Expression <Func <TSource, TDest> > >)factoryDelegate;
expression = factory(param1, param2);
expressions.Add(id, expression);
TryRemoveFactory(id);
return(true);
}
if (_dynamicExpressionFactories.TryGetValue(id, out factoryDelegate))
{
factory = (Func <TParam1, TParam2, Expression <Func <TSource, TDest> > >)factoryDelegate;
expression = factory(param1, param2);
return(true);
}
if (activator != null)
{
ISelectExpression <TSource, TDest, TParam1, TParam2> selectResolver = activator();
factory = selectResolver.GetSelectExpression;
if (selectResolver is ISelectDynamicExpression <TSource, TDest, TParam1, TParam2> )
{
_dynamicExpressionFactories.Add(id, factory);
expression = factory(param1, param2);
return(true);
}
else
{
_expressionFactories.Add(id, factory);
expression = factory(param1, param2);
expressions.Add(id, expression);
TryRemoveFactory(id);
return(true);
}
}
}
expression = null;
return(false);
}
/// <summary>
/// Prepares an explicitly defined select clause.
/// </summary>
/// <param name="fromClause">The from clause linked to this select clause.</param>
/// <exception cref="SemanticException"></exception>
public void InitializeExplicitSelectClause(FromClause fromClause)
{
if (_prepared)
{
throw new InvalidOperationException("SelectClause was already prepared!");
}
//explicit = true; // This is an explict Select.
//ArrayList sqlResultTypeList = new ArrayList();
List <IType> queryReturnTypeList = new List <IType>();
// First, collect all of the select expressions.
// NOTE: This must be done *before* invoking setScalarColumnText() because setScalarColumnText()
// changes the AST!!!
ISelectExpression[] selectExpressions = CollectSelectExpressions();
for (int i = 0; i < selectExpressions.Length; i++)
{
ISelectExpression expr = selectExpressions[i];
if (expr.IsConstructor)
{
_constructorNode = (ConstructorNode)expr;
IList <IType> constructorArgumentTypeList = _constructorNode.ConstructorArgumentTypeList;
//sqlResultTypeList.addAll( constructorArgumentTypeList );
queryReturnTypeList.AddRange(constructorArgumentTypeList);
_scalarSelect = true;
for (int j = 1; j < _constructorNode.ChildCount; j++)
{
ISelectExpression se = _constructorNode.GetChild(j) as ISelectExpression;
if (se != null && IsReturnableEntity(se))
{
_fromElementsForLoad.Add(se.FromElement);
}
}
}
else
{
IType type = expr.DataType;
if (type == null && !(expr is ParameterNode))
{
throw new QueryException("No data type for node: " + expr.GetType().Name + " " + new ASTPrinter().ShowAsString((IASTNode)expr, ""));
}
//sqlResultTypeList.add( type );
// If the data type is not an association type, it could not have been in the FROM clause.
if (expr.IsScalar)
{
_scalarSelect = true;
}
if (IsReturnableEntity(expr))
{
_fromElementsForLoad.Add(expr.FromElement);
}
// Always add the type to the return type list.
queryReturnTypeList.Add(type);
}
}
//init the aliases, after initing the constructornode
InitAliases(selectExpressions);
if (!Walker.IsShallowQuery)
{
// add the fetched entities
IList <IASTNode> fromElements = fromClause.GetProjectionList();
ASTAppender appender = new ASTAppender(ASTFactory, this); // Get ready to start adding nodes.
int size = fromElements.Count;
int k = 0;
foreach (FromElement fromElement in fromElements)
{
if (fromElement.IsFetch)
{
var origin = GetOrigin(fromElement);
// Only perform the fetch if its owner is included in the select
if (!_fromElementsForLoad.Contains(origin))
{
// NH-2846: Before 2012-01-18, we threw this exception. However, some
// components using LINQ (e.g. paging) like to automatically append e.g. Count(). It
// can then be difficult to avoid having a bogus fetch statement, so just ignore those.
// An alternative solution may be to have the linq provider filter out the fetch instead.
// throw new QueryException(string.Format(JoinFetchWithoutOwnerExceptionMsg, fromElement.GetDisplayText()));
//throw away the fromElement. It's clearly redundant.
fromElement.Parent.RemoveChild(fromElement);
}
else
{
IType type = fromElement.SelectType;
AddCollectionFromElement(fromElement);
if (type != null)
{
bool collectionOfElements = fromElement.IsCollectionOfValuesOrComponents;
if (!collectionOfElements)
{
// Add the type to the list of returned sqlResultTypes.
fromElement.IncludeSubclasses = true;
_fromElementsForLoad.Add(fromElement);
//sqlResultTypeList.add( type );
// Generate the select expression.
String text = fromElement.RenderIdentifierSelect(size, k);
SelectExpressionImpl generatedExpr = (SelectExpressionImpl)appender.Append(HqlSqlWalker.SELECT_EXPR, text, false);
if (generatedExpr != null)
{
generatedExpr.FromElement = fromElement;
}
}
}
}
}
k++;
}
// generate id select fragment and then property select fragment for
// each expression, just like generateSelectFragments().
RenderNonScalarSelects(CollectSelectExpressions(true), fromClause);
}
if (_scalarSelect || Walker.IsShallowQuery)
{
// If there are any scalars (non-entities) selected, render the select column aliases.
RenderScalarSelects(selectExpressions, fromClause);
}
FinishInitialization(/*sqlResultTypeList,*/ queryReturnTypeList);
}
private void RenderNonScalarSelects(ISelectExpression[] selectExpressions, FromClause currentFromClause)
{
var appender = new ASTAppender(ASTFactory, this);
var nonscalarSize = selectExpressions.Count(e => !e.IsScalar);
int j = 0;
foreach (var e in selectExpressions)
{
if (!e.IsScalar)
{
FromElement fromElement = e.FromElement;
if (fromElement != null)
{
RenderNonScalarIdentifiers(fromElement, nonscalarSize, j, e, appender);
j++;
}
}
}
if (!currentFromClause.IsSubQuery)
{
// Generate the property select tokens.
int k = 0;
foreach (var e in selectExpressions)
{
if (!e.IsScalar)
{
FromElement fromElement = e.FromElement;
if (fromElement != null)
{
RenderNonScalarProperties(appender, fromElement, nonscalarSize, k);
k++;
}
}
}
}
}
private void AddEntityToProjection(int resultIndex, ISelectExpression se)
{
_entityByResultTypeDic[resultIndex] = _fromElementsForLoad.Count;
_fromElementsForLoad.Add(se.FromElement);
}
private static void RenderScalarSelects(ISelectExpression[] se, FromClause currentFromClause)
{
if (!currentFromClause.IsSubQuery)
{
for (int i = 0; i < se.Length; i++)
{
ISelectExpression expr = se[i];
expr.SetScalarColumnText(i); // Create SQL_TOKEN nodes for the columns.
}
}
}
private void RenderNonScalarIdentifiers(FromElement fromElement, int nonscalarSize, int j, ISelectExpression expr, ASTAppender appender)
{
string text = fromElement.RenderIdentifierSelect(nonscalarSize, j);
if (!fromElement.FromClause.IsSubQuery)
{
if (!_scalarSelect && !Walker.IsShallowQuery)
{
//TODO: is this a bit ugly?
expr.Text = text;
}
else
{
appender.Append(HqlSqlWalker.SQL_TOKEN, text, false);
}
}
}
/**
* Prepares an explicitly defined select clause.
*
* @param fromClause The from clause linked to this select clause.
* @throws SemanticException
*/
public void InitializeExplicitSelectClause(FromClause fromClause)
{
if (_prepared)
{
throw new InvalidOperationException("SelectClause was already prepared!");
}
//explicit = true; // This is an explict Select.
//ArrayList sqlResultTypeList = new ArrayList();
List <IType> queryReturnTypeList = new List <IType>();
// First, collect all of the select expressions.
// NOTE: This must be done *before* invoking setScalarColumnText() because setScalarColumnText()
// changes the AST!!!
ISelectExpression[] selectExpressions = CollectSelectExpressions();
for (int i = 0; i < selectExpressions.Length; i++)
{
ISelectExpression expr = selectExpressions[i];
if (expr.IsConstructor)
{
_constructorNode = ( ConstructorNode )expr;
IList <IType> constructorArgumentTypeList = _constructorNode.ConstructorArgumentTypeList;
//sqlResultTypeList.addAll( constructorArgumentTypeList );
queryReturnTypeList.AddRange(constructorArgumentTypeList);
_scalarSelect = true;
for (int j = 1; j < _constructorNode.ChildCount; j++)
{
ISelectExpression se = _constructorNode.GetChild(j) as ISelectExpression;
if (se != null && IsReturnableEntity(se))
{
_fromElementsForLoad.Add(se.FromElement);
}
}
}
else
{
IType type = expr.DataType;
if (type == null)
{
throw new QueryException("No data type for node: " + expr.GetType().Name + " " + new ASTPrinter().ShowAsString((IASTNode)expr, ""));
}
//sqlResultTypeList.add( type );
// If the data type is not an association type, it could not have been in the FROM clause.
if (expr.IsScalar)
{
_scalarSelect = true;
}
if (IsReturnableEntity(expr))
{
_fromElementsForLoad.Add(expr.FromElement);
}
// Always add the type to the return type list.
queryReturnTypeList.Add(type);
}
}
//init the aliases, after initing the constructornode
InitAliases(selectExpressions);
if (!Walker.IsShallowQuery)
{
// add the fetched entities
IList <IASTNode> fromElements = fromClause.GetProjectionList();
ASTAppender appender = new ASTAppender(ASTFactory, this); // Get ready to start adding nodes.
int size = fromElements.Count;
int k = 0;
foreach (FromElement fromElement in fromElements)
{
if (fromElement.IsFetch)
{
FromElement origin;
if (fromElement.RealOrigin == null)
{
// work around that crazy issue where the tree contains
// "empty" FromElements (no text); afaict, this is caused
// by FromElementFactory.createCollectionJoin()
if (fromElement.Origin == null)
{
throw new QueryException("Unable to determine origin of join fetch [" + fromElement.GetDisplayText() + "]");
}
origin = fromElement.Origin;
}
else
{
origin = fromElement.RealOrigin;
}
if (!_fromElementsForLoad.Contains(origin))
{
throw new QueryException(string.Format(JoinFetchWithoutOwnerExceptionMsg, fromElement.GetDisplayText()));
}
IType type = fromElement.SelectType;
AddCollectionFromElement(fromElement);
if (type != null)
{
bool collectionOfElements = fromElement.IsCollectionOfValuesOrComponents;
if (!collectionOfElements)
{
// Add the type to the list of returned sqlResultTypes.
fromElement.IncludeSubclasses = true;
_fromElementsForLoad.Add(fromElement);
//sqlResultTypeList.add( type );
// Generate the select expression.
String text = fromElement.RenderIdentifierSelect(size, k);
SelectExpressionImpl generatedExpr = ( SelectExpressionImpl )appender.Append(HqlSqlWalker.SELECT_EXPR, text, false);
if (generatedExpr != null)
{
generatedExpr.FromElement = fromElement;
}
}
}
}
k++;
}
// generate id select fragment and then property select fragment for
// each expression, just like generateSelectFragments().
RenderNonScalarSelects(CollectSelectExpressions(true), fromClause);
}
if (_scalarSelect || Walker.IsShallowQuery)
{
// If there are any scalars (non-entities) selected, render the select column aliases.
RenderScalarSelects(selectExpressions, fromClause);
}
FinishInitialization(/*sqlResultTypeList,*/ queryReturnTypeList);
}
protected override void Configure(TQuery request)
{
base.Configure(request);
Select = GetSelectExpression();
}
