internal StringBuilder AsEsql(StringBuilder builder, string blockAlias, int indentLevel)
{
StringUtil.IndentNewLine(builder, indentLevel + 1);
builder.Append("RELATIONSHIP(");
var fields = new List <string>();
// If the variable is a relation end, we will gets it scope Extent, e.g., CPerson1 for the CPerson end of CPersonAddress1.
builder.Append("CREATEREF(");
CqlWriter.AppendEscapedQualifiedName(builder, m_toEndEntitySet.EntityContainer.Name, m_toEndEntitySet.Name);
builder.Append(", ROW(");
foreach (var memberPath in m_toEndEntityKeyMemberPaths)
{
var fullFieldAlias = CqlWriter.GetQualifiedName(blockAlias, memberPath.CqlFieldAlias);
fields.Add(fullFieldAlias);
}
StringUtil.ToSeparatedString(builder, fields, ", ", null);
builder.Append(')');
builder.Append(",");
CqlWriter.AppendEscapedTypeName(builder, m_toEndEntityType);
builder.Append(')');
builder.Append(',');
CqlWriter.AppendEscapedTypeName(builder, m_associationSet.ElementType);
builder.Append(',');
CqlWriter.AppendEscapedName(builder, m_fromEnd.Name);
builder.Append(',');
CqlWriter.AppendEscapedName(builder, m_toEnd.Name);
builder.Append(')');
builder.Append(' ');
return(builder);
}
internal StringBuilder AsEsql(
StringBuilder builder,
string blockAlias,
int indentLevel)
{
StringUtil.IndentNewLine(builder, indentLevel + 1);
builder.Append("RELATIONSHIP(");
List <string> stringList = new List <string>();
builder.Append("CREATEREF(");
CqlWriter.AppendEscapedQualifiedName(builder, this.m_toEndEntitySet.EntityContainer.Name, this.m_toEndEntitySet.Name);
builder.Append(", ROW(");
foreach (MemberPath entityKeyMemberPath in this.m_toEndEntityKeyMemberPaths)
{
string qualifiedName = CqlWriter.GetQualifiedName(blockAlias, entityKeyMemberPath.CqlFieldAlias);
stringList.Add(qualifiedName);
}
StringUtil.ToSeparatedString(builder, (IEnumerable)stringList, ", ", (string)null);
builder.Append(')');
builder.Append(",");
CqlWriter.AppendEscapedTypeName(builder, (EdmType)this.m_toEndEntityType);
builder.Append(')');
builder.Append(',');
CqlWriter.AppendEscapedTypeName(builder, (EdmType)this.m_associationSet.ElementType);
builder.Append(',');
CqlWriter.AppendEscapedName(builder, this.m_fromEnd.Name);
builder.Append(',');
CqlWriter.AppendEscapedName(builder, this.m_toEnd.Name);
builder.Append(')');
builder.Append(' ');
return(builder);
}
// <summary>
// Given a member path and an alias, returns an eSQL string correspondng to the fully-qualified name
// <paramref
// name="blockAlias" />
// .path, e.g., T1.Address.Phone.Zip.
// If a subcomponent belongs to subclass, generates a treat for it, e.g. "TREAT(T1 as Customer).Address".
// Or even "TREAT(TREAT(T1 AS Customer).Address as USAddress).Zip".
// </summary>
internal StringBuilder AsEsql(StringBuilder inputBuilder, string blockAlias)
{
// Due to the TREAT stuff, we cannot build incrementally.
// So we use a local StringBuilder - it should not be that inefficient (one extra copy).
var builder = new StringBuilder();
// Add blockAlias as a starting point for blockAlias.member1.member2...
CqlWriter.AppendEscapedName(builder, blockAlias);
// Process all items in the path.
AsCql(
// accessMember action
(memberName) =>
{
builder.Append('.');
CqlWriter.AppendEscapedName(builder, memberName);
},
// getKey action
() =>
{
builder.Insert(0, "Key(");
builder.Append(")");
},
// treatAs action
(treatAsType) =>
{
builder.Insert(0, "TREAT(");
builder.Append(" AS ");
CqlWriter.AppendEscapedTypeName(builder, treatAsType);
builder.Append(')');
});
inputBuilder.Append(builder);
return(inputBuilder);
}
internal override StringBuilder AsEsql(StringBuilder builder, string blockAlias, bool skipIsNotNull)
{
// Get e.g., T2._from1 using the table alias
string qualifiedName = CqlWriter.GetQualifiedName(blockAlias, SlotName);
builder.Append(qualifiedName);
return(builder);
}
internal override StringBuilder AsEsql(StringBuilder builder, MemberPath outputMember, string blockAlias)
{
DebugCheck.NotNull(outputMember.LeafEdmMember);
var constType = Helper.GetModelTypeUsage(outputMember.LeafEdmMember).EdmType;
builder.Append("CAST(NULL AS ");
CqlWriter.AppendEscapedTypeName(builder, constType);
builder.Append(')');
return(builder);
}
internal override StringBuilder AsEsql(StringBuilder builder, MemberPath outputMember, string blockAlias)
{
Debug.Assert(outputMember.LeafEdmMember != null, "Constant can't correspond to an empty member path.");
EdmType constType = Helper.GetModelTypeUsage(outputMember.LeafEdmMember).EdmType;
builder.Append("CAST(NULL AS ");
CqlWriter.AppendEscapedTypeName(builder, constType);
builder.Append(')');
return(builder);
}
internal override StringBuilder AsEsql(
StringBuilder builder,
string blockAlias,
bool skipIsNotNull)
{
string qualifiedName = CqlWriter.GetQualifiedName(blockAlias, this.SlotName);
builder.Append(qualifiedName);
return(builder);
}
internal override StringBuilder AsEsql(StringBuilder builder, MemberPath outputMember, string blockAlias)
{
DebugCheck.NotNull(outputMember.LeafEdmMember);
var modelTypeUsage = Helper.GetModelTypeUsage(outputMember.LeafEdmMember);
var modelType = modelTypeUsage.EdmType;
// Some built-in constants
if (BuiltInTypeKind.PrimitiveType
== modelType.BuiltInTypeKind)
{
var primitiveTypeKind = ((PrimitiveType)modelType).PrimitiveTypeKind;
if (primitiveTypeKind == PrimitiveTypeKind.Boolean)
{
// This better be a boolean. Else we crash!
var val = (bool)m_scalar;
var value = StringUtil.FormatInvariant("{0}", val);
builder.Append(value);
return(builder);
}
else if (primitiveTypeKind == PrimitiveTypeKind.String)
{
bool isUnicode;
if (!TypeHelpers.TryGetIsUnicode(modelTypeUsage, out isUnicode))
{
// If can't determine - use the safest option, assume unicode.
isUnicode = true;
}
if (isUnicode)
{
builder.Append('N');
}
AppendEscapedScalar(builder);
return(builder);
}
}
else if (BuiltInTypeKind.EnumType
== modelType.BuiltInTypeKind)
{
// Enumerated type - we should be able to cast it
var enumMember = (EnumMember)m_scalar;
builder.Append(enumMember.Name);
return(builder);
}
// Need to cast
builder.Append("CAST(");
AppendEscapedScalar(builder);
builder.Append(" AS ");
CqlWriter.AppendEscapedTypeName(builder, modelType);
builder.Append(')');
return(builder);
}
internal override StringBuilder AsUserString(StringBuilder builder, string blockAlias, bool skipIsNotNull)
{
// Add user readable string of the form "T.A IS a (Person OR .....)"
if (Helper.IsRefType(RestrictedMemberSlot.MemberPath.EdmType))
{
builder.Append("Deref(");
RestrictedMemberSlot.MemberPath.AsEsql(builder, blockAlias);
builder.Append(')');
}
else
{
// non-reference type
RestrictedMemberSlot.MemberPath.AsEsql(builder, blockAlias);
}
if (Domain.Count > 1)
{
builder.Append(" is a (");
}
else
{
builder.Append(" is type ");
}
bool isFirst = true;
foreach (Constant constant in Domain.Values)
{
TypeConstant typeConstant = constant as TypeConstant;
Debug.Assert(typeConstant != null || constant.IsNull(), "Constants for type checks must be type constants or NULLs");
if (isFirst == false)
{
builder.Append(" OR ");
}
if (constant.IsNull())
{
builder.Append(" NULL");
}
else
{
CqlWriter.AppendEscapedTypeName(builder, typeConstant.EdmType);
}
isFirst = false;
}
if (Domain.Count > 1)
{
builder.Append(')');
}
return(builder);
}
internal override StringBuilder AsEsql(StringBuilder builder, string blockAlias, bool skipIsNotNull)
{
// Add Cql of the form "(T.A IS OF (ONLY Person) OR .....)"
// Important to enclose all the OR statements in parens.
if (this.Domain.Count > 1)
{
builder.Append('(');
}
bool isFirst = true;
foreach (Constant constant in this.Domain.Values)
{
TypeConstant typeConstant = constant as TypeConstant;
Debug.Assert(typeConstant != null || constant.IsNull(), "Constants for type checks must be type constants or NULLs");
if (isFirst == false)
{
builder.Append(" OR ");
}
isFirst = false;
if (Helper.IsRefType(this.RestrictedMemberSlot.MemberPath.EdmType))
{
builder.Append("Deref(");
this.RestrictedMemberSlot.MemberPath.AsEsql(builder, blockAlias);
builder.Append(')');
}
else
{
// non-reference type
this.RestrictedMemberSlot.MemberPath.AsEsql(builder, blockAlias);
}
if (constant.IsNull())
{
builder.Append(" IS NULL");
}
else
{
// type constant
builder.Append(" IS OF (ONLY ");
CqlWriter.AppendEscapedTypeName(builder, typeConstant.EdmType);
builder.Append(')');
}
}
if (Domain.Count > 1)
{
builder.Append(')');
}
return(builder);
}
internal override StringBuilder AsUserString(
StringBuilder builder,
string blockAlias,
bool skipIsNotNull)
{
if (Helper.IsRefType((GlobalItem)this.RestrictedMemberSlot.MemberPath.EdmType))
{
builder.Append("Deref(");
this.RestrictedMemberSlot.MemberPath.AsEsql(builder, blockAlias);
builder.Append(')');
}
else
{
this.RestrictedMemberSlot.MemberPath.AsEsql(builder, blockAlias);
}
if (this.Domain.Count > 1)
{
builder.Append(" is a (");
}
else
{
builder.Append(" is type ");
}
bool flag = true;
foreach (Constant constant in this.Domain.Values)
{
TypeConstant typeConstant = constant as TypeConstant;
if (!flag)
{
builder.Append(" OR ");
}
if (constant.IsNull())
{
builder.Append(" NULL");
}
else
{
CqlWriter.AppendEscapedTypeName(builder, typeConstant.EdmType);
}
flag = false;
}
if (this.Domain.Count > 1)
{
builder.Append(')');
}
return(builder);
}
internal override StringBuilder AsEsql(StringBuilder builder, MemberPath outputMember, string blockAlias)
{
AsCql(
// createRef action
(refScopeEntitySet, keyMemberOutputPaths) =>
{
// Construct a scoped reference: CreateRef(CPerson1Set, NewRow(pid1, pid2), CPerson1)
EntityType refEntityType = (EntityType)(((RefType)outputMember.EdmType).ElementType);
builder.Append("CreateRef(");
CqlWriter.AppendEscapedQualifiedName(builder, refScopeEntitySet.EntityContainer.Name, refScopeEntitySet.Name);
builder.Append(", row(");
for (int i = 0; i < keyMemberOutputPaths.Count; ++i)
{
if (i > 0)
{
builder.Append(", ");
}
// Given the member, we need its aliased name
string fullFieldAlias = CqlWriter.GetQualifiedName(blockAlias, keyMemberOutputPaths[i].CqlFieldAlias);
builder.Append(fullFieldAlias);
}
builder.Append("), ");
CqlWriter.AppendEscapedTypeName(builder, refEntityType);
builder.Append(')');
},
// createType action
(membersOutputPaths) =>
{
// Construct an entity/complex/Association type in the Members order for fields: CPerson(CPerson1_Pid, CPerson1_Name)
CqlWriter.AppendEscapedTypeName(builder, m_edmType);
builder.Append('(');
for (int i = 0; i < membersOutputPaths.Count; ++i)
{
if (i > 0)
{
builder.Append(", ");
}
// Given the member, we need its aliased name: CPerson1_Pid
string fullFieldAlias = CqlWriter.GetQualifiedName(blockAlias, membersOutputPaths[i].CqlFieldAlias);
builder.Append(fullFieldAlias);
}
builder.Append(')');
},
outputMember);
return(builder);
}
internal override StringBuilder AsEsql(StringBuilder builder, MemberPath outputMember, string blockAlias, int indentLevel)
{
TypeUsage outputMemberStoreTypeUsage;
if (NeedToCastCqlValue(outputMember, out outputMemberStoreTypeUsage))
{
builder.Append("CAST(");
m_memberPath.AsEsql(builder, blockAlias);
builder.Append(" AS ");
CqlWriter.AppendEscapedTypeName(builder, outputMemberStoreTypeUsage.EdmType);
builder.Append(')');
}
else
{
m_memberPath.AsEsql(builder, blockAlias);
}
return(builder);
}
internal override StringBuilder AsEsql(
StringBuilder builder,
MemberPath outputMember,
string blockAlias)
{
TypeUsage modelTypeUsage = Helper.GetModelTypeUsage(outputMember.LeafEdmMember);
EdmType edmType = modelTypeUsage.EdmType;
if (BuiltInTypeKind.PrimitiveType == edmType.BuiltInTypeKind)
{
switch (((PrimitiveType)edmType).PrimitiveTypeKind)
{
case PrimitiveTypeKind.Boolean:
string str = StringUtil.FormatInvariant("{0}", (object)(bool)this.m_scalar);
builder.Append(str);
return(builder);
case PrimitiveTypeKind.String:
bool isUnicode;
if (!TypeHelpers.TryGetIsUnicode(modelTypeUsage, out isUnicode))
{
isUnicode = true;
}
if (isUnicode)
{
builder.Append('N');
}
this.AppendEscapedScalar(builder);
return(builder);
}
}
else if (BuiltInTypeKind.EnumType == edmType.BuiltInTypeKind)
{
EnumMember scalar = (EnumMember)this.m_scalar;
builder.Append(scalar.Name);
return(builder);
}
builder.Append("CAST(");
this.AppendEscapedScalar(builder);
builder.Append(" AS ");
CqlWriter.AppendEscapedTypeName(builder, edmType);
builder.Append(')');
return(builder);
}
internal string ToESqlString()
{
StringBuilder builder = new StringBuilder();
builder.Append("\n\tSELECT ");
if (m_selectDistinct == SelectDistinct.Yes)
{
builder.Append("DISTINCT ");
}
foreach (ProjectedSlot ps in m_projectedSlots)
{
MemberProjectedSlot jtn = ps as MemberProjectedSlot;
StructuralType st = jtn.MemberPath.LeafEdmMember.DeclaringType;
StringBuilder sb = new StringBuilder();
jtn.MemberPath.AsEsql(sb, "e");
builder.AppendFormat("{0}, ", sb.ToString());
}
//remove the extra-comma after the last slot
builder.Remove(builder.Length - 2, 2);
builder.Append("\n\tFROM ");
EntitySetBase extent = m_extentMemberPath.Extent;
CqlWriter.AppendEscapedQualifiedName(builder, extent.EntityContainer.Name, extent.Name);
builder.Append(" AS e");
if (m_whereClause.IsTrue == false)
{
builder.Append("\n\tWHERE ");
StringBuilder qbuilder = new StringBuilder();
m_whereClause.AsEsql(qbuilder, "e");
builder.Append(qbuilder.ToString());
}
builder.Append("\n ");
return(builder.ToString());
}
internal override StringBuilder AsEsql(
StringBuilder builder,
MemberPath outputMember,
string blockAlias)
{
this.AsCql((Action <EntitySet, IList <MemberPath> >)((refScopeEntitySet, keyMemberOutputPaths) =>
{
EntityType elementType = (EntityType)((RefType)outputMember.EdmType).ElementType;
builder.Append("CreateRef(");
CqlWriter.AppendEscapedQualifiedName(builder, refScopeEntitySet.EntityContainer.Name, refScopeEntitySet.Name);
builder.Append(", row(");
for (int index = 0; index < keyMemberOutputPaths.Count; ++index)
{
if (index > 0)
{
builder.Append(", ");
}
builder.Append(CqlWriter.GetQualifiedName(blockAlias, keyMemberOutputPaths[index].CqlFieldAlias));
}
builder.Append("), ");
CqlWriter.AppendEscapedTypeName(builder, (EdmType)elementType);
builder.Append(')');
}), (Action <IList <MemberPath> >)(membersOutputPaths =>
{
CqlWriter.AppendEscapedTypeName(builder, this.m_edmType);
builder.Append('(');
for (int index = 0; index < membersOutputPaths.Count; ++index)
{
if (index > 0)
{
builder.Append(", ");
}
builder.Append(CqlWriter.GetQualifiedName(blockAlias, membersOutputPaths[index].CqlFieldAlias));
}
builder.Append(')');
}), outputMember);
return(builder);
}
internal StringBuilder AsEsql(StringBuilder inputBuilder, string blockAlias)
{
StringBuilder builder = new StringBuilder();
CqlWriter.AppendEscapedName(builder, blockAlias);
this.AsCql((Action <string>)(memberName =>
{
builder.Append('.');
CqlWriter.AppendEscapedName(builder, memberName);
}), (Action)(() =>
{
builder.Insert(0, "Key(");
builder.Append(")");
}), (Action <StructuralType>)(treatAsType =>
{
builder.Insert(0, "TREAT(");
builder.Append(" AS ");
CqlWriter.AppendEscapedTypeName(builder, (EdmType)treatAsType);
builder.Append(')');
}));
inputBuilder.Append((object)builder);
return(inputBuilder);
}
