public override bool ShouldCacheRelation(RelationInfo relation, ClassInfo classInfo)
{
if (classInfo.Cardinality == ClassCardinality.Small || classInfo.Cardinality == ClassCardinality.Medium)
return true;
else
return false;
}
private ClassInfo GetRootClass(ClassInfo ci)
{
if (ci.InheritsFromClass != null)
return GetRootClass(ci.InheritsFromClass);
else
return ci;
}
public CodeDomClassStubGenerator(ClassInfo ci, SoodaProject options)
{
this.classInfo = ci;
this.options = options;
string keyGen = "none";
if (!ci.ReadOnly && ci.GetPrimaryKeyFields().Length == 1)
{
switch (ci.GetFirstPrimaryKeyField().DataType)
{
case FieldDataType.Integer:
keyGen = "integer";
break;
case FieldDataType.Guid:
keyGen = "guid";
break;
case FieldDataType.Long:
keyGen = "long";
break;
}
}
if (ci.KeyGenName != null)
keyGen = ci.KeyGenName;
this.KeyGen = keyGen;
}
public override bool ShouldCacheCollection(ClassInfo classInfo, SoodaWhereClause whereClause, SoodaOrderBy orderBy, int startIdx, int pageCount)
{
if (classInfo.Cardinality == ClassCardinality.Small || classInfo.Cardinality == ClassCardinality.Medium)
return true;
else
return false;
}
public static SoqlBooleanExpression ClassRestriction(SoqlPathExpression path, SchemaInfo schema, ClassInfo classInfo)
{
// returns no additional filter clause for parent (master-parent) class
if (classInfo.InheritsFromClass == null)
return null;
SoqlExpressionCollection literals = new SoqlExpressionCollection();
foreach (ClassInfo subclass in classInfo.GetSubclassesForSchema(schema))
{
if (subclass.SubclassSelectorValue != null)
{
literals.Add(new SoqlLiteralExpression(subclass.SubclassSelectorValue));
}
}
if (classInfo.SubclassSelectorValue != null)
{
literals.Add(new SoqlLiteralExpression(classInfo.SubclassSelectorValue));
}
// returns false when class is abstract (no SubClassSelectorValue) and there is no subclasses
if (literals.Count == 0)
return new SoqlBooleanLiteralExpression(false);
SoqlBooleanExpression restriction = new SoqlBooleanInExpression(
new SoqlPathExpression(path, classInfo.SubclassSelectorField.Name),
literals
);
return restriction;
}
public void Resolve()
{
if (Includes == null)
{
Includes = new List <IncludeInfo>();
}
classNameHash = new Hashtable(StringComparer.OrdinalIgnoreCase);
relationNameHash = new Hashtable(StringComparer.OrdinalIgnoreCase);
Rehash();
_backRefCollections = new Dictionary <string, StringCollection>();
foreach (ClassInfo ci in Classes)
{
ci.ResolveInheritance(this);
}
Resolve(Classes);
if (Relations != null)
{
foreach (RelationInfo ri in Relations)
{
ri.Resolve(this);
}
}
foreach (DataSourceInfo dsi in DataSources)
{
dsi.Resolve();
}
LocalClasses = new List <ClassInfo>();
foreach (ClassInfo ci in Classes)
{
if (ci.Schema == this)
{
LocalClasses.Add(ci);
}
}
LocalRelations = new List <RelationInfo>();
foreach (RelationInfo ri in Relations)
{
if (ri.Schema == this)
{
LocalRelations.Add(ri);
}
}
_subclasses = new Dictionary <string, List <ClassInfo> >();
foreach (ClassInfo ci in Classes)
{
_subclasses[ci.Name] = new List <ClassInfo>();
}
foreach (ClassInfo ci0 in Classes)
{
for (ClassInfo ci = ci0.InheritsFromClass; ci != null; ci = ci.InheritsFromClass)
{
_subclasses[ci.Name].Add(ci0);
}
}
}
public void GenerateFields(CodeTypeDeclaration ctd, ClassInfo ci)
{
if (GetFieldRefCacheCount(ci) > 0)
{
CodeMemberField field = new CodeMemberField(new CodeTypeReference(new CodeTypeReference("SoodaObject"), 1), "_refcache");
field.Attributes = MemberAttributes.Private;
field.InitExpression = new CodeArrayCreateExpression(
new CodeTypeReference(typeof(SoodaObject)), new CodePrimitiveExpression(GetFieldRefCacheCount(ci)));
ctd.Members.Add(field);
}
if (classInfo.Collections1toN != null)
{
foreach (CollectionOnetoManyInfo coli in classInfo.Collections1toN)
{
ctd.Members.Add(GetCollectionCache(coli));
}
foreach (CollectionOnetoManyInfo coli in classInfo.Collections1toN)
{
CodeMemberField field = new CodeMemberField("Sooda.SoodaWhereClause", "_collectionWhere_" + coli.Name);
field.Attributes = MemberAttributes.Static | MemberAttributes.Private;
if (!string.IsNullOrEmpty(coli.Where))
{
field.InitExpression = new CodeObjectCreateExpression(
"Sooda.SoodaWhereClause",
new CodePrimitiveExpression(coli.Where));
}
else
{
field.InitExpression = new CodePrimitiveExpression(null);
}
ctd.Members.Add(field);
}
}
if (classInfo.CollectionsNtoN != null)
{
foreach (CollectionManyToManyInfo coli in classInfo.CollectionsNtoN)
{
ctd.Members.Add(GetCollectionCache(coli));
}
}
}
static CodeExpression RefCacheExpression(ClassInfo ci, FieldInfo fi)
{
return new CodeArrayIndexerExpression(RefCacheArray(),
new CodePrimitiveExpression(GetFieldRefCacheIndex(ci, fi)));
}
static int GetFieldRefCacheIndex(ClassInfo ci, FieldInfo fi0)
{
int p = 0;
foreach (FieldInfo fi in ci.LocalFields)
{
if (fi == fi0)
return p;
if (fi.ReferencedClass != null)
p++;
}
return -1;
}
private void GenerateLoaderClass(CodeNamespace nspace, ClassInfo ci)
{
if (!string.IsNullOrEmpty(ci.Schema.AssemblyName))
return;
CodeTypeDeclaration ctd = GetLoaderClass(ci);
nspace.Types.Add(ctd);
}
public bool GetExpirationTimeout(RelationInfo relation, ClassInfo resultClass, int itemCount, out TimeSpan expirationTimeout, out bool slidingExpiration)
{
expirationTimeout = _expirationTimeout;
slidingExpiration = _slidingExpiration;
return true;
}
public bool GetExpirationTimeout(ClassInfo classInfo, SoodaWhereClause whereClause, SoodaOrderBy orderBy, int startIdx, int pageCount, int itemCount, out TimeSpan expirationTimeout, out bool slidingExpiration)
{
expirationTimeout = _expirationTimeout;
slidingExpiration = _slidingExpiration;
return true;
}
public SoodaObjectOneToManyCollection(SoodaTransaction tran, Type childType, SoodaObject parentObject, string childRefField, Sooda.Schema.ClassInfo classInfo, SoodaWhereClause additionalWhereClause, bool cached)
: base(tran, classInfo)
{
this.childType = childType;
this.parentObject = parentObject;
this.childRefField = childRefField;
this.additionalWhereClause = additionalWhereClause;
this.cached = cached;
}
static void Resolve(ClassInfo ci)
{
Resolve(ci.Schema, new HashSet <ClassInfo> {
ci
});
}
private void GenerateConditionalSets(CodeStatementCollection stats, int min, int max, ClassInfo ci)
{
if (!string.IsNullOrEmpty(ci.Schema.AssemblyName))
return;
if (min >= max)
{
stats.Add(new CodeCommentStatement("ordinal: " + min));
return;
}
// stats.Add(new CodeCommentStatement("range: [" + min + ".." + max + "]"));
int mid = (min + max) / 2;
CodeConditionStatement ifStatement = new CodeConditionStatement();
ifStatement.Condition = new CodeBinaryOperatorExpression(
new CodeArgumentReferenceExpression("fieldOrdinal"),
CodeBinaryOperatorType.LessThanOrEqual,
new CodePrimitiveExpression(mid));
stats.Add(ifStatement);
GenerateConditionalSets(ifStatement.TrueStatements, min, mid, ci);
GenerateConditionalSets(ifStatement.FalseStatements, mid + 1, max, ci);
}
private void GenerateTypedInternalQueryWrappers(CodeNamespace ns, ClassInfo ci)
{
if (!string.IsNullOrEmpty(ci.Schema.AssemblyName))
return;
CDILContext context = new CDILContext();
context["ClassName"] = ci.Name;
context["PrimaryKeyType"] = ci.GetFirstPrimaryKeyField().GetNullableFieldHandler().GetFieldType().FullName;
context["CSharp"] = _codeProvider is Microsoft.CSharp.CSharpCodeProvider;
CodeTypeDeclaration ctd = CDILParser.ParseClass(CDILTemplate.Get("TypedCollectionWrapper.cdil"), context);
ns.Types.Add(ctd);
context = new CDILContext();
context["ClassName"] = ci.Name;
context["PrimaryKeyType"] = ci.GetFirstPrimaryKeyField().GetNullableFieldHandler().GetFieldType().FullName;
context["CSharp"] = _codeProvider is Microsoft.CSharp.CSharpCodeProvider;
context["ParameterAttributes"] = _codeGenerator.Supports(GeneratorSupport.ParameterAttributes);
ctd = CDILParser.ParseClass(CDILTemplate.Get("TypedWrapper.cdil"), context);
ns.Types.Add(ctd);
foreach (CollectionBaseInfo coll in ci.UnifiedCollections)
{
CodeMemberProperty prop = new CodeMemberProperty();
prop.Name = coll.Name;
prop.Attributes = MemberAttributes.Public;
prop.Type = new CodeTypeReference(coll.GetItemClass().Name + "CollectionExpression");
prop.GetStatements.Add(
new CodeMethodReturnStatement(
new CodeObjectCreateExpression(prop.Type, new CodeThisReferenceExpression(), new CodePrimitiveExpression(coll.Name))
));
ctd.Members.Add(prop);
}
foreach (FieldInfo fi in ci.UnifiedFields)
{
CodeMemberProperty prop = new CodeMemberProperty();
prop.Name = fi.Name;
prop.Attributes = MemberAttributes.Public;
string fullWrapperTypeName;
string optionalNullable = fi.IsNullable ? "Nullable" : "";
if (fi.ReferencedClass == null)
{
fullWrapperTypeName = fi.GetFieldHandler().GetTypedWrapperClass();
if (fullWrapperTypeName == null)
continue;
prop.GetStatements.Add(new CodeMethodReturnStatement(
new CodeObjectCreateExpression(fullWrapperTypeName,
new CodeObjectCreateExpression("Sooda.QL.SoqlPathExpression", new CodeThisReferenceExpression(), new CodePrimitiveExpression(fi.Name)))));
}
else
{
fullWrapperTypeName = fi.ReferencedClass.Name + optionalNullable + "WrapperExpression";
prop.GetStatements.Add(new CodeMethodReturnStatement(
new CodeObjectCreateExpression(fullWrapperTypeName,
new CodeThisReferenceExpression(), new CodePrimitiveExpression(fi.Name))));
}
prop.Type = new CodeTypeReference(fullWrapperTypeName);
ctd.Members.Add(prop);
}
CodeTypeDeclaration nullablectd = CDILParser.ParseClass(CDILTemplate.Get("NullableTypedWrapper.cdil"), context);
ns.Types.Add(nullablectd);
}
private void GenerateTypedPublicQueryWrappers(CodeNamespace ns, ClassInfo ci)
{
if (!string.IsNullOrEmpty(ci.Schema.AssemblyName))
return;
CDILContext context = new CDILContext();
context["ClassName"] = ci.Name;
CodeTypeDeclaration ctd = CDILParser.ParseClass(CDILTemplate.Get("ClassField.cdil"), context);
ns.Types.Add(ctd);
foreach (CollectionBaseInfo coll in ci.UnifiedCollections)
{
CodeMemberProperty prop = new CodeMemberProperty();
prop.Name = coll.Name;
prop.Attributes = MemberAttributes.Public | MemberAttributes.Static;
prop.Type = new CodeTypeReference(coll.GetItemClass().Name + "CollectionExpression");
prop.GetStatements.Add(
new CodeMethodReturnStatement(
new CodeObjectCreateExpression(prop.Type, new CodePrimitiveExpression(null), new CodePrimitiveExpression(coll.Name))
));
ctd.Members.Add(prop);
}
foreach (FieldInfo fi in ci.UnifiedFields)
{
CodeMemberProperty prop = new CodeMemberProperty();
prop.Name = fi.Name;
prop.Attributes = MemberAttributes.Public | MemberAttributes.Static;
string fullWrapperTypeName;
string optionalNullable = "";
if (fi.IsNullable)
optionalNullable = "Nullable";
if (fi.ReferencedClass == null)
{
fullWrapperTypeName = fi.GetFieldHandler().GetTypedWrapperClass();
if (fullWrapperTypeName == null)
continue;
prop.GetStatements.Add(new CodeMethodReturnStatement(
new CodeObjectCreateExpression(fullWrapperTypeName,
new CodeObjectCreateExpression("Sooda.QL.SoqlPathExpression", new CodePrimitiveExpression(fi.Name)))));
}
else
{
fullWrapperTypeName = fi.ReferencedClass.Name + optionalNullable + "WrapperExpression";
prop.GetStatements.Add(new CodeMethodReturnStatement(
new CodeObjectCreateExpression(fullWrapperTypeName,
new CodePrimitiveExpression(null), new CodePrimitiveExpression(fi.Name))));
}
prop.Type = new CodeTypeReference(fullWrapperTypeName);
ctd.Members.Add(prop);
}
}
private void DumpTable(SchemaInfo schemaInfo, string owner, string table)
{
Console.WriteLine("Dumping table {0}.{1}", owner, table);
ClassInfo ci = new ClassInfo();
ci.Name = MakePascalCase(table);
TableInfo ti = new TableInfo();
ci.LocalTables = new List<TableInfo>();
ti.DBTableName = table;
ci.LocalTables.Add(ti);
foreach (DataRow r in dataSet.Tables["Columns"].Select("TABLE_NAME='" + table + "' and TABLE_OWNER='" + owner + "'", "ORDINAL_POSITION"))
{
try
{
string columnName = r["COLUMN_NAME"].ToString();
FieldInfo fi = new FieldInfo();
fi.Name = MakePascalCase(columnName);
fi.DBColumnName = columnName;
GetSoodaFieldAttributes(fi, r, false);
ti.Fields.Add(fi);
}
catch (Exception ex)
{
Console.WriteLine("WARNING: {0}", ex.Message);
}
}
bool hasPrimaryKey = false;
foreach (DataRow r in dataSet.Tables["PrimaryKeys"].Select("TABLE_NAME='" + table + "' and TABLE_OWNER='" + owner + "'"))
{
string column = Convert.ToString(r["COLUMN_NAME"]);
foreach (FieldInfo fi in ti.Fields)
{
if (0 == String.Compare(fi.DBColumnName, column, true))
{
fi.IsPrimaryKey = true;
hasPrimaryKey = true;
}
}
}
if (!hasPrimaryKey)
{
Console.WriteLine("WARNING: Created artificial primary key from the first column of the " + ti.DBTableName + " table. This may be incorrect.");
ti.Fields[0].IsPrimaryKey = true;
}
schemaInfo.Classes.Add(ci);
}
internal void ResolveInheritance(SchemaInfo schema)
{
if (InheritFrom != null)
{
InheritsFromClass = schema.FindClassByName(InheritFrom);
}
else
{
InheritsFromClass = null;
}
}
public static string GetCollectionKey(ClassInfo classInfo, SoodaWhereClause wc)
{
return GetCollectionKey(classInfo.Name, wc);
}
public abstract bool ShouldCacheCollection(ClassInfo classInfo, SoodaWhereClause whereClause, SoodaOrderBy orderBy, int startIdx, int pageCount);
public CodeTypeDeclaration GetLoaderClass(ClassInfo ci)
{
CDILContext context = new CDILContext();
context["ClassName"] = ci.Name;
context["HasBaseClass"] = ci.InheritsFromClass != null;
string formalParameters = "";
string actualParameters = "";
foreach (FieldInfo fi in ci.GetPrimaryKeyFields())
{
if (formalParameters != "")
{
formalParameters += ", ";
actualParameters += ", ";
}
string pkClrTypeName = fi.GetNullableFieldHandler().GetFieldType().FullName;
formalParameters += pkClrTypeName + " " + MakeCamelCase(fi.Name);
actualParameters += "arg(" + MakeCamelCase(fi.Name) + ")";
}
context["PrimaryKeyFormalParameters"] = formalParameters;
context["PrimaryKeyActualParameters"] = actualParameters;
if (ci.GetPrimaryKeyFields().Length == 1)
{
context["PrimaryKeyActualParametersTuple"] = actualParameters;
context["PrimaryKeyIsTuple"] = false;
}
else
{
context["PrimaryKeyIsTuple"] = true;
context["PrimaryKeyActualParametersTuple"] = "new SoodaTuple(" + actualParameters + ")";
}
context["ClassUnifiedFieldCount"] = ci.UnifiedFields.Count;
context["PrimaryKeyFieldHandler"] = ci.GetFirstPrimaryKeyField().GetNullableFieldHandler().GetType().FullName;
context["OptionalNewAttribute"] = ci.InheritsFromClass != null ? ",New" : "";
if (_codeProvider is Microsoft.VisualBasic.VBCodeProvider)
{
context["OptionalNewAttribute"] = "";
}
if (Project.LoaderClass)
{
context["LoaderClass"] = /*Project.OutputNamespace.Replace(".", "") + "." + */ci.Name + "Loader";
context["OptionalNewAttribute"] = "";
}
else
context["LoaderClass"] = /*Project.OutputNamespace.Replace(".", "") + "Stubs." + */ci.Name + "_Stub";
context["WithSoql"] = Project.WithSoql;
#if DOTNET35
context["Linq"] = true;
#else
context["Linq"] = false;
#endif
CodeTypeDeclaration ctd = CDILParser.ParseClass(CDILTemplate.Get("Loader.cdil"), context);
foreach (FieldInfo fi in ci.LocalFields)
{
GenerateFindMethod(ctd, fi, false);
GenerateFindMethod(ctd, fi, true);
}
return ctd;
}
internal void Merge(ClassInfo merge)
{
Hashtable mergeNames = new Hashtable();
foreach (TableInfo mti in this.LocalTables)
mergeNames.Add(mti.DBTableName, mti);
foreach (TableInfo ti in merge.LocalTables)
{
if (mergeNames.ContainsKey(ti.DBTableName))
((TableInfo)mergeNames[ti.DBTableName]).Merge(ti);
else
LocalTables.Add(ti);
}
mergeNames.Clear();
if (this.Collections1toN != null)
{
foreach (CollectionOnetoManyInfo ci in Collections1toN)
mergeNames.Add(ci.Name, ci);
}
if (this.Collections1toN == null)
this.Collections1toN = merge.Collections1toN;
else
{
if (merge.Collections1toN != null)
{
foreach (CollectionOnetoManyInfo mci in merge.Collections1toN)
if (mergeNames.ContainsKey(mci.Name))
throw new SoodaSchemaException(String.Format("Duplicate collection 1:N '{0}' found!", mci.Name));
this.Collections1toN = (CollectionOnetoManyInfo[])MergeArray(this.Collections1toN, merge.Collections1toN);
}
}
mergeNames.Clear();
if (this.CollectionsNtoN != null)
{
foreach (CollectionManyToManyInfo ci in CollectionsNtoN)
mergeNames.Add(ci.Name, ci);
}
if (this.CollectionsNtoN == null)
this.CollectionsNtoN = merge.CollectionsNtoN;
else
{
if (merge.CollectionsNtoN != null)
{
foreach (CollectionManyToManyInfo mci in merge.CollectionsNtoN)
if (mergeNames.ContainsKey(mci.Name))
throw new SoodaSchemaException(String.Format("Duplicate collection N:N '{0}' found!", mci.Name));
this.CollectionsNtoN = (CollectionManyToManyInfo[])MergeArray(this.CollectionsNtoN, merge.CollectionsNtoN);
}
}
mergeNames.Clear();
if (this.Constants != null)
{
foreach (ConstantInfo ci in Constants)
mergeNames.Add(ci.Name, ci);
}
if (this.Constants == null)
this.Constants = merge.Constants;
else
{
if (merge.Constants != null)
{
foreach (ConstantInfo mci in merge.Constants)
if (mergeNames.ContainsKey(mci.Name))
throw new SoodaSchemaException(String.Format("Duplicate constant name '{0}' found!", mci.Name));
this.Constants = (ConstantInfo[])MergeArray(this.Constants, merge.Constants);
}
}
}
public abstract bool ShouldCacheRelation(RelationInfo relation, ClassInfo resultClass);
private CodeTypeReferenceExpression LoaderClass(ClassInfo ci)
{
if (options.LoaderClass)
return new CodeTypeReferenceExpression(ci.Name + "Loader");
else
return new CodeTypeReferenceExpression(ci.Name + "_Stub");
}
public void AddClass(ClassInfo ci)
{
Classes.Add(ci);
Rehash();
}
static int GetFieldRefCacheCount(ClassInfo ci)
{
int p = 0;
foreach (FieldInfo fi in ci.LocalFields)
{
if (fi.ReferencedClass != null)
p++;
}
return p;
}
internal List<ClassInfo> GetSubclasses(ClassInfo ci)
{
List<ClassInfo> subclasses;
_subclasses.TryGetValue(ci.Name, out subclasses);
return subclasses;
}
public void GenerateProperties(CodeTypeDeclaration ctd, ClassInfo ci)
{
CodeMemberProperty prop;
foreach (FieldInfo fi in classInfo.LocalFields)
{
if (fi.References != null)
continue;
if (fi.IsNullable)
{
if (options.NullableRepresentation == PrimitiveRepresentation.RawWithIsNull)
{
ctd.Members.Add(_IsNull(fi));
if (!ci.ReadOnly)
{
ctd.Members.Add(_SetNull(fi));
}
}
}
else
{
if (options.NotNullRepresentation == PrimitiveRepresentation.RawWithIsNull)
{
if (!ci.ReadOnly)
{
// if it's read-only, not-null means not-null and there's no
// exception
ctd.Members.Add(_IsNull(fi));
}
}
}
}
int primaryKeyComponentNumber = 0;
foreach (FieldInfo fi in classInfo.LocalFields)
{
PrimitiveRepresentation actualNullableRepresentation = options.NullableRepresentation;
PrimitiveRepresentation actualNotNullRepresentation = options.NotNullRepresentation;
if (fi.GetNullableFieldHandler().GetSqlType() == null)
{
if (actualNotNullRepresentation == PrimitiveRepresentation.SqlType)
actualNotNullRepresentation = PrimitiveRepresentation.Raw;
if (actualNullableRepresentation == PrimitiveRepresentation.SqlType)
actualNullableRepresentation = PrimitiveRepresentation.Raw;
}
CodeTypeReference returnType;
//if (fi.Name == ci.PrimaryKeyFieldName)
//{
// returnType = GetReturnType(PrimitiveRepresentation.Raw, fi.DataType);
//}
//else
if (fi.References != null)
{
returnType = new CodeTypeReference(fi.References);
}
else if (fi.IsNullable)
{
returnType = GetReturnType(actualNullableRepresentation, fi);
}
else
{
returnType = GetReturnType(actualNotNullRepresentation, fi);
}
prop = new CodeMemberProperty();
prop.Name = fi.Name;
prop.Attributes = MemberAttributes.Final | MemberAttributes.Public;
prop.Type = returnType;
//prop.GetStatements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(null, "_FieldNames")));
if (fi.Description != null)
{
prop.Comments.Add(new CodeCommentStatement("<summary>", true));
prop.Comments.Add(new CodeCommentStatement(fi.Description, true));
prop.Comments.Add(new CodeCommentStatement("</summary>", true));
}
ctd.Members.Add(prop);
if (fi.Size != -1)
{
CodeAttributeDeclaration cad = new CodeAttributeDeclaration("Sooda.SoodaFieldSizeAttribute");
cad.Arguments.Add(new CodeAttributeArgument(new CodePrimitiveExpression(fi.Size)));
prop.CustomAttributes.Add(cad);
}
if (fi.IsPrimaryKey)
{
CodeExpression getPrimaryKeyValue = new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), "GetPrimaryKeyValue");
if (classInfo.GetPrimaryKeyFields().Length > 1)
{
getPrimaryKeyValue = new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(typeof(SoodaTuple)), "GetValue", getPrimaryKeyValue, new CodePrimitiveExpression(primaryKeyComponentNumber));
}
if (fi.References != null)
{
prop.GetStatements.Add(
new CodeMethodReturnStatement(
new CodeMethodInvokeExpression(
LoaderClass(fi.ReferencedClass),
"GetRef",
GetTransaction(),
new CodeCastExpression(
GetReturnType(actualNotNullRepresentation, fi),
getPrimaryKeyValue
))));
}
else
{
prop.GetStatements.Add(
new CodeMethodReturnStatement(
new CodeCastExpression(
prop.Type,
getPrimaryKeyValue
)));
}
if (!classInfo.ReadOnly && !fi.ReadOnly)
{
if (classInfo.GetPrimaryKeyFields().Length == 1)
{
prop.SetStatements.Add(
new CodeExpressionStatement(
new CodeMethodInvokeExpression(
new CodeThisReferenceExpression(), "SetPrimaryKeyValue",
new CodePropertySetValueReferenceExpression())));
}
else
{
CodeExpression plainValue = new CodePropertySetValueReferenceExpression();
if (fi.References != null)
plainValue = new CodeMethodInvokeExpression(plainValue, "GetPrimaryKeyValue");
prop.SetStatements.Add(
new CodeExpressionStatement(
new CodeMethodInvokeExpression(
new CodeThisReferenceExpression(), "SetPrimaryKeySubValue",
plainValue,
new CodePrimitiveExpression(primaryKeyComponentNumber),
new CodePrimitiveExpression(classInfo.GetPrimaryKeyFields().Length))));
}
}
primaryKeyComponentNumber++;
continue;
}
if (options.NullPropagation && (fi.References != null || fi.IsNullable) && actualNullableRepresentation != PrimitiveRepresentation.Raw)
{
CodeExpression retVal = new CodePrimitiveExpression(null);
if (fi.References == null && actualNullableRepresentation == PrimitiveRepresentation.SqlType)
{
retVal = new CodePropertyReferenceExpression(
new CodeTypeReferenceExpression(fi.GetNullableFieldHandler().GetSqlType()), "Null");
}
prop.GetStatements.Add(
new CodeConditionStatement(
new CodeBinaryOperatorExpression(
new CodeThisReferenceExpression(),
CodeBinaryOperatorType.IdentityEquality,
new CodePrimitiveExpression(null)),
new CodeStatement[]
{
new CodeMethodReturnStatement(retVal)
},
new CodeStatement[]
{
}));
}
if (fi.References != null)
{
// reference field getter
//
CodeExpression pk = new CodeVariableReferenceExpression("pk");
Type pkType;
CodeExpression isFieldNotNull;
CodeExpression getRef;
if (fi.ParentClass.GetDataSource().EnableDynamicFields)
{
pkType = typeof(object);
isFieldNotNull = new CodeBinaryOperatorExpression(
pk,
CodeBinaryOperatorType.IdentityInequality,
new CodePrimitiveExpression(null));
getRef = new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(typeof(SoodaObject)),
"GetRefHelper",
GetTransaction(),
Factory(fi.References),
pk);
}
else
{
pkType = fi.GetNullableFieldHandler().GetSqlType();
isFieldNotNull = new CodeBinaryOperatorExpression(
new CodePropertyReferenceExpression(pk, "IsNull"),
CodeBinaryOperatorType.ValueEquality,
new CodePrimitiveExpression(false));
getRef = new CodeMethodInvokeExpression(
LoaderClass(fi.ReferencedClass),
"GetRef",
GetTransaction(),
new CodePropertyReferenceExpression(pk, "Value"));
}
prop.GetStatements.Add(
new CodeConditionStatement(
new CodeBinaryOperatorExpression(
RefCacheExpression(ci, fi),
CodeBinaryOperatorType.IdentityEquality,
new CodePrimitiveExpression(null)),
new CodeStatement[]
{
new CodeVariableDeclarationStatement(pkType, "pk", GetFieldValueForRead(fi)),
new CodeConditionStatement(
isFieldNotNull,
new CodeStatement[]
{
new CodeAssignStatement(
RefCacheExpression(ci, fi),
getRef)
})
}
));
prop.GetStatements.Add(
new CodeMethodReturnStatement(
new CodeCastExpression(returnType,
RefCacheExpression(ci, fi))));
// reference field setter
if (!classInfo.ReadOnly && !fi.ReadOnly)
{
prop.SetStatements.Add(
new CodeExpressionStatement(
new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(typeof(Sooda.ObjectMapper.SoodaObjectImpl)), "SetRefFieldValue",
// parameters
new CodeThisReferenceExpression(),
new CodePrimitiveExpression(fi.Table.OrdinalInClass),
new CodePrimitiveExpression(fi.Name),
new CodePrimitiveExpression(fi.ClassUnifiedOrdinal),
new CodePropertySetValueReferenceExpression(),
RefCacheArray(),
new CodePrimitiveExpression(GetFieldRefCacheIndex(ci, fi)),
Factory(returnType.BaseType)
)));
}
}
else
{
// plain field getter
CodeExpression fieldValue = GetFieldValueForRead(fi);
if (fi.ParentClass.GetDataSource().EnableDynamicFields)
{
switch (fi.IsNullable ? actualNullableRepresentation : actualNotNullRepresentation)
{
case PrimitiveRepresentation.Boxed:
break;
case PrimitiveRepresentation.SqlType:
case PrimitiveRepresentation.RawWithIsNull:
case PrimitiveRepresentation.Raw:
fieldValue = new CodeCastExpression(new CodeTypeReference(fi.GetNullableFieldHandler().GetFieldType()), fieldValue);
break;
case PrimitiveRepresentation.Nullable:
fieldValue = new CodeCastExpression(new CodeTypeReference(fi.GetNullableFieldHandler().GetNullableType()), fieldValue);
break;
default:
throw new NotImplementedException("Unknown PrimitiveRepresentation");
}
}
prop.GetStatements.Add(new CodeMethodReturnStatement(fieldValue));
if (!classInfo.ReadOnly && !fi.ReadOnly)
{
// plain field setter
CodeExpression beforeDelegate = new CodePrimitiveExpression(null);
CodeExpression afterDelegate = new CodePrimitiveExpression(null);
if (classInfo.Triggers)
{
beforeDelegate = new CodeDelegateCreateExpression(new CodeTypeReference(typeof(SoodaFieldUpdateDelegate)),
new CodeThisReferenceExpression(), "BeforeFieldUpdate_" + fi.Name);
afterDelegate = new CodeDelegateCreateExpression(new CodeTypeReference(typeof(SoodaFieldUpdateDelegate)),
new CodeThisReferenceExpression(), "AfterFieldUpdate_" + fi.Name);
}
prop.SetStatements.Add(
new CodeExpressionStatement(
new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(typeof(Sooda.ObjectMapper.SoodaObjectImpl)), "SetPlainFieldValue",
// parameters
new CodeThisReferenceExpression(),
new CodePrimitiveExpression(fi.Table.OrdinalInClass),
new CodePrimitiveExpression(fi.Name),
new CodePrimitiveExpression(fi.ClassUnifiedOrdinal),
Box(new CodePropertySetValueReferenceExpression()),
beforeDelegate,
afterDelegate
)));
}
}
}
if (classInfo.Collections1toN != null)
{
foreach (CollectionOnetoManyInfo coli in classInfo.Collections1toN)
{
prop = new CodeMemberProperty();
prop.Name = coli.Name;
prop.Attributes = MemberAttributes.Final | MemberAttributes.Public;
prop.Type = GetCollectionPropertyType(coli.ClassName);
prop.GetStatements.Add(
new CodeConditionStatement(
new CodeBinaryOperatorExpression(
new CodeFieldReferenceExpression(This, "_collectionCache_" + coli.Name),
CodeBinaryOperatorType.IdentityEquality,
new CodePrimitiveExpression(null)), new CodeStatement[]
{
new CodeAssignStatement(
new CodeFieldReferenceExpression(This, "_collectionCache_" + coli.Name),
new CodeObjectCreateExpression(GetCollectionWrapperType(coli.ClassName),
new CodeObjectCreateExpression(new CodeTypeReference(typeof(Sooda.ObjectMapper.SoodaObjectOneToManyCollection)),
new CodeExpression[] {
new CodeMethodInvokeExpression(This, "GetTransaction"),
new CodeTypeOfExpression(new CodeTypeReference(coli.ClassName)),
new CodeThisReferenceExpression(),
new CodePrimitiveExpression(coli.ForeignFieldName),
new CodePropertyReferenceExpression(new CodeTypeReferenceExpression(coli.ClassName + "_Factory"), "TheClassInfo"),
new CodeFieldReferenceExpression(null, "_collectionWhere_" + coli.Name),
new CodePrimitiveExpression(coli.Cache)
}))),
}, new CodeStatement[] { }));
prop.GetStatements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(This, "_collectionCache_" + coli.Name)));
ctd.Members.Add(prop);
#if DOTNET35
CodeExpression whereExpression = new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(typeof(Sooda.QL.Soql)),
"FieldEquals",
new CodePrimitiveExpression(coli.ForeignFieldName),
This);
if (!string.IsNullOrEmpty(coli.Where))
{
whereExpression = new CodeObjectCreateExpression(
typeof(Sooda.QL.SoqlBooleanAndExpression),
whereExpression,
new CodePropertyReferenceExpression(new CodeFieldReferenceExpression(null, "_collectionWhere_" + coli.Name), "WhereExpression"));
}
prop = GetCollectionLinqQuery(coli, whereExpression);
ctd.Members.Add(prop);
#endif
}
}
if (classInfo.CollectionsNtoN != null)
{
foreach (CollectionManyToManyInfo coli in classInfo.CollectionsNtoN)
{
RelationInfo relationInfo = coli.GetRelationInfo();
// FieldInfo masterField = relationInfo.Table.Fields[1 - coli.MasterField];
string relationTargetClass = relationInfo.Table.Fields[coli.MasterField].References;
prop = new CodeMemberProperty();
prop.Name = coli.Name;
prop.Attributes = MemberAttributes.Final | MemberAttributes.Public;
prop.Type = GetCollectionPropertyType(relationTargetClass);
prop.GetStatements.Add(
new CodeConditionStatement(
new CodeBinaryOperatorExpression(
new CodeFieldReferenceExpression(This, "_collectionCache_" + coli.Name),
CodeBinaryOperatorType.IdentityEquality,
new CodePrimitiveExpression(null)), new CodeStatement[] {
new CodeAssignStatement(
new CodeFieldReferenceExpression(This, "_collectionCache_" + coli.Name),
new CodeObjectCreateExpression(GetCollectionWrapperType(relationTargetClass),
new CodeObjectCreateExpression(new CodeTypeReference(typeof(Sooda.ObjectMapper.SoodaObjectManyToManyCollection)),
new CodeExpression[] {
new CodeMethodInvokeExpression(This, "GetTransaction"),
new CodePrimitiveExpression(coli.MasterField),
new CodeMethodInvokeExpression(This, "GetPrimaryKeyValue"),
new CodeTypeOfExpression(relationInfo.Name + "_RelationTable"),
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(relationInfo.Name + "_RelationTable"), "theRelationInfo")
}))
),
}
, new CodeStatement[] { }));
prop.GetStatements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(This, "_collectionCache_" + coli.Name)));
ctd.Members.Add(prop);
#if DOTNET35
CodeExpression whereExpression = new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(typeof(Sooda.QL.Soql)),
"CollectionFor",
new CodeMethodInvokeExpression(
new CodePropertyReferenceExpression(new CodeTypeReferenceExpression(classInfo.Name + "_Factory"), "TheClassInfo"),
"FindCollectionManyToMany",
new CodePrimitiveExpression(coli.Name)),
This);
prop = GetCollectionLinqQuery(coli, whereExpression);
ctd.Members.Add(prop);
#endif
}
}
}
public override bool ShouldCacheCollection(ClassInfo classInfo, SoodaWhereClause whereClause, SoodaOrderBy orderBy, int startIdx, int pageCount)
{
return false;
}
public override bool ShouldCacheRelation(RelationInfo relation, ClassInfo classInfo)
{
return false;
}
public TableInfo Clone(ClassInfo newParent)
{
TableInfo tableInfo = (TableInfo) this.MemberwiseClone();
tableInfo.OwnerClass = newParent;
return tableInfo;
}
static int CompareNames(ClassInfo x, ClassInfo y)
{
return x.Name.CompareTo(y.Name);
}
public void AddClass(ClassInfo ci)
{
Classes.Add(ci);
Rehash();
}
