public virtual ProjectionExpression AddOuterJoinTest(ProjectionExpression proj)
{
var test = this.GetOuterJoinTest(proj.Select);
var select = proj.Select;
FieldExpression testCol = null;
// look to see if test expression exists in fields already
foreach (var col in select.Fields)
{
if (test.Equals(col.Expression))
{
var colType = this.TypeSystem.GetStorageType(test.Type);
testCol = new FieldExpression(test.Type, colType, select.Alias, col.Name);
break;
}
}
if (testCol == null)
{
// add expression to projection
testCol = test as FieldExpression;
string colName = (testCol != null) ? testCol.Name : "Test";
colName = proj.Select.Fields.GetAvailableFieldName(colName);
var colType = this.TypeSystem.GetStorageType(test.Type);
select = select.AddField(new FieldDeclaration(colName, test, colType));
testCol = new FieldExpression(test.Type, colType, select.Alias, colName);
}
var newProjector = new OuterJoinedExpression(testCol, proj.Projector);
return new ProjectionExpression(select, newProjector, proj.Aggregator);
}
protected override Expression VisitField(FieldExpression field)
{
if (this.oldAliases.Contains(field.Alias))
{
return new FieldExpression(field.Type, field.QueryType, this.newAlias, field.Name);
}
return field;
}
protected override Expression VisitField(FieldExpression field)
{
IdentifiableAlias mapped;
if (this.map.TryGetValue(field.Alias, out mapped))
{
return new FieldExpression(field.Type, field.QueryType, mapped, field.Name);
}
return field;
}
protected override Expression VisitField(FieldExpression field)
{
FieldExpression mapped;
if (this.map.TryGetValue(field, out mapped))
{
return mapped;
}
return field;
}
protected override Expression VisitField(FieldExpression field)
{
Dictionary<string, Expression> nameMap;
if (this.map.TryGetValue(field.Alias, out nameMap))
{
Expression expr;
if (nameMap.TryGetValue(field.Name, out expr))
{
return this.Visit(expr);
}
throw new Exception("Reference to undefined field");
}
return field;
}
protected override Expression VisitSelect(SelectExpression select)
{
select = (SelectExpression)base.VisitSelect(select);
// look for redundant field declarations
List<FieldDeclaration> cols = select.Fields.OrderBy(c => c.Name).ToList();
BitArray removed = new BitArray(select.Fields.Count);
bool anyRemoved = false;
for (int i = 0, n = cols.Count; i < n - 1; i++)
{
FieldDeclaration ci = cols[i];
FieldExpression cix = ci.Expression as FieldExpression;
StorageType qt = cix != null ? cix.QueryType : ci.QueryType;
FieldExpression cxi = new FieldExpression(ci.Expression.Type, qt, select.Alias, ci.Name);
for (int j = i + 1; j < n; j++)
{
if (!removed.Get(j))
{
FieldDeclaration cj = cols[j];
if (SameExpression(ci.Expression, cj.Expression))
{
// any reference to 'j' should now just be a reference to 'i'
FieldExpression cxj = new FieldExpression(cj.Expression.Type, qt, select.Alias, cj.Name);
this.map.Add(cxj, cxi);
removed.Set(j, true);
anyRemoved = true;
}
}
}
}
if (anyRemoved)
{
List<FieldDeclaration> newDecls = new List<FieldDeclaration>();
for (int i = 0, n = cols.Count; i < n; i++)
{
if (!removed.Get(i))
{
newDecls.Add(cols[i]);
}
}
select = select.SetFields(newDecls);
}
return select;
}
protected FieldAssignment UpdateFieldAssignment(FieldAssignment ca, FieldExpression c, Expression e)
{
if (c != ca.Field || e != ca.Expression)
{
return new FieldAssignment(c, e);
}
return ca;
}
protected override Expression VisitField(FieldExpression field)
{
if (field.Alias != null && !this.HideFieldAliases)
{
this.WriteAliasName(GetAliasName(field.Alias));
this.Write(".");
}
this.WriteFieldName(field.Name);
return field;
}
protected override Expression Visit(Expression expression)
{
if (this.candidates.Contains(expression))
{
if (expression.NodeType == (ExpressionType)DbExpressionType.Field)
{
FieldExpression field = (FieldExpression)expression;
FieldExpression mapped;
if (this.map.TryGetValue(field, out mapped))
{
return mapped;
}
// check for field that already refers to this field
foreach (FieldDeclaration existingField in this.fields)
{
FieldExpression cex = existingField.Expression as FieldExpression;
if (cex != null && cex.Alias == field.Alias && cex.Name == field.Name)
{
// refer to the field already in the field list
return new FieldExpression(field.Type, field.QueryType, this.newAlias, existingField.Name);
}
}
if (this.existingAliases.Contains(field.Alias))
{
int ordinal = this.fields.Count;
string fieldName = this.GetUniqueFieldName(field.Name);
this.fields.Add(new FieldDeclaration(fieldName, field, field.QueryType));
mapped = new FieldExpression(field.Type, field.QueryType, this.newAlias, fieldName);
this.map.Add(field, mapped);
this.fieldNames.Add(fieldName);
return mapped;
}
// must be referring to outer scope
return field;
}
else
{
string fieldName = this.GetNextFieldName();
var colType = this.language.TypeSystem.GetStorageType(expression.Type);
this.fields.Add(new FieldDeclaration(fieldName, expression, colType));
return new FieldExpression(expression.Type, colType, this.newAlias, fieldName);
}
}
else
{
return base.Visit(expression);
}
}
protected override Expression VisitField(FieldExpression field)
{
MarkFieldAsUsed(field.Alias, field.Name);
return field;
}
private Expression BindAnyAll(Expression source, MethodInfo method, LambdaExpression predicate, bool isRoot)
{
bool isAll = method.Name == "All";
ConstantExpression constSource = source as ConstantExpression;
if (constSource != null && !IsQuery(constSource))
{
System.Diagnostics.Debug.Assert(!isRoot);
Expression where = null;
foreach (object value in (IEnumerable)constSource.Value)
{
Expression expr = Expression.Invoke(predicate, Expression.Constant(value, predicate.Parameters[0].Type));
if (where == null)
{
where = expr;
}
else if (isAll)
{
where = where.And(expr);
}
else
{
where = where.Or(expr);
}
}
return this.Visit(where);
}
else
{
if (isAll)
{
predicate = Expression.Lambda(Expression.Not(predicate.Body), predicate.Parameters.ToArray());
}
if (predicate != null)
{
source = Expression.Call(typeof(Enumerable), "Where", method.GetGenericArguments(), source, predicate);
}
ProjectionExpression projection = this.VisitSequence(source);
Expression result = new ExistsExpression(projection.Select);
if (isAll)
{
result = Expression.Not(result);
}
if (isRoot)
{
if (this.language.AllowSubqueryInSelectWithoutFrom)
{
return GetSingletonSequence(result, "SingleOrDefault");
}
else
{
// use count aggregate instead of exists
var colType = this.language.TypeSystem.GetStorageType(typeof(int));
var newSelect = projection.Select.SetFields(
new[] { new FieldDeclaration("value", new AggregateExpression(typeof(int), "Count", null, false), colType) }
);
var colx = new FieldExpression(typeof(int), colType, newSelect.Alias, "value");
var exp = isAll
? colx.Equal(Expression.Constant(0))
: colx.GreaterThan(Expression.Constant(0));
return new ProjectionExpression(
newSelect, exp, Aggregator.GetAggregator(typeof(bool), typeof(IEnumerable<bool>))
);
}
}
return result;
}
}
protected override Expression VisitField(FieldExpression field)
{
this.aliases.Add(field.Alias);
return field;
}
protected virtual bool CompareField(FieldExpression a, FieldExpression b)
{
return this.CompareAlias(a.Alias, b.Alias) && a.Name == b.Name;
}
protected override Expression VisitField(FieldExpression field)
{
ParameterExpression fieldReader;
int iOrdinal;
if (this.Scope != null && this.Scope.TryGetValue(field, out fieldReader, out iOrdinal))
{
// different query types may not be able to guarantee the ordinal position of results
// in the reader. for these types, the Scope.UseOrdinalMapping will be set to false
if (this.Scope.UseOrdinalMapping)
{
MethodInfo method = OFieldReader.GetReaderMethod(field.Type, this.Scope.UseOrdinalMapping);
return Expression.Call(fieldReader, method, Expression.Constant(iOrdinal));
}
else
{
MethodInfo method = OFieldReader.GetReaderMethod(field.Type, this.Scope.UseOrdinalMapping);
return Expression.Call(fieldReader, method, Expression.Constant(field.Name));
}
}
else
{
System.Diagnostics.Debug.Fail(string.Format("Field not in scope: {0}", field));
}
return field;
}
protected virtual Expression VisitField(FieldExpression field)
{
int iAlias;
string aliasName =
this.aliasMap.TryGetValue(field.Alias, out iAlias)
? "A" + iAlias
: "A" + (field.Alias != null ? field.Alias.GetHashCode().ToString() : "") + "?";
this.Write(aliasName);
this.Write(".");
this.Write("Field(\"");
this.Write(field.Name);
this.Write("\")");
return field;
}
protected override Expression VisitField(FieldExpression field)
{
_fields.Add(field);
return base.VisitField(field);
}
protected virtual Expression VisitField(FieldExpression field)
{
return field;
}
protected override Expression VisitField(FieldExpression field)
{
//if (field.Alias != null && !this.HideFieldAliases)
//{
// this.WriteAliasName(GetAliasName(field.Alias));
// this.Write(".");
//}
if (field.Name.Equals("Id"))
{
this.WriteFieldName("@rid");
}
//else if (field.Type.Implements<IIdentifiable>())
//{
// var mapping = this.Linguist.Translator.Mapper.Mapping.GetEntity(field.Type, this.Linguist.Translator.Mapper.Mapping.RepositoryType);
// this.Write(mapping.StorageClass);
//}
else
{
this.WriteFieldName(field.Name);
//WriteIfNullField(field);
}
return field;
}
//private void WriteIfNullField(FieldExpression field)
//{
// this.Write(string.Format("IfNull({0}, {1}) as {0}", field.Name, FieldDefaultValue(field)));
//}
private string FieldDefaultValue(FieldExpression field)
{
if (field.Type.Equals(typeof(bool))
|| field.Type.Equals(typeof(byte))
|| field.Type.Equals(typeof(sbyte))
|| field.Type.Equals(typeof(char))
|| field.Type.Equals(typeof(short))
|| field.Type.Equals(typeof(ushort))
|| field.Type.Equals(typeof(int))
|| field.Type.Equals(typeof(uint))
|| field.Type.Equals(typeof(long))
|| field.Type.Equals(typeof(ulong)))
{
return 0.ToOrientValueString();
}
else if (field.Type.Equals(typeof(float))
|| field.Type.Equals(typeof(double)))
{
return (0.0d).ToOrientValueString();
}
else if (field.Type.Equals(typeof(decimal)))
{
return (0.0m).ToOrientValueString();
}
else if (field.Type.Equals(typeof(DateTime)))
{
return (new DateTime(1970, 1, 1, 0, 0, 0)).ToOrientValueString();
}
else if (field.Type.Equals(typeof(string)))
{
return "".ToOrientValueString();
}
else return "null"; // not sure how to handle defaults for arrays...
}
public FieldAssignment(FieldExpression field, Expression expression)
{
this.field = field;
this.expression = expression;
}