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;
}
static void Resolve(SchemaInfo schema, HashSet<ClassInfo> affectedClasses)
{
// add subclasses
foreach (ClassInfo ci in affectedClasses.ToArray())
{
foreach (ClassInfo sci in schema.GetSubclasses(ci))
affectedClasses.Add(sci);
}
schema.Resolve(affectedClasses);
}
public static void ProcessIncludes(SchemaInfo resultSchema, List<IncludeInfo> includes, string baseDirectoryForIncludes)
{
if (includes == null)
return;
foreach (IncludeInfo ii in includes)
{
string includeFileName = Path.Combine(baseDirectoryForIncludes, ii.SchemaFile);
SchemaInfo includedSchema = ReadAndValidateSchema(new XmlTextReader(includeFileName), Path.GetDirectoryName(includeFileName), ii);
resultSchema.MergeIncludedSchema(includedSchema);
includedSchema.AssemblyName = ii.AssemblyName;
includedSchema.Namespace = ii.Namespace;
ii.Schema = includedSchema;
}
}
internal void Resolve(SchemaInfo schemaInfo)
{
relationInfo = schemaInfo.FindRelationByName(Relation);
if (relationInfo == null)
throw new SoodaSchemaException("Relation " + Relation + " not found.");
if (ForeignField != null)
{
if (relationInfo.Table.Fields[0].Name == ForeignField)
MasterField = 1;
else
MasterField = 0;
}
if (MasterField == -1)
throw new SoodaConfigException("You need to set either masterField or foreignField in <collectionManyToMany name='" + this.Name + "' />");
}
public override SchemaInfo GetSchemaFromDatabase(ISchemaImporterOptions options)
{
_options = options;
using (SqlConnection conn = new SqlConnection(options.ConnectionString))
{
SqlDataAdapter dataAdapter;
conn.Open();
Console.WriteLine("Loading tables...");
dataAdapter = new SqlDataAdapter(SqlStrings.TablesQuery, conn);
dataAdapter.Fill(dataSet, "Tables");
Console.WriteLine("Loading datatypes...");
dataAdapter.SelectCommand.CommandText = "exec sp_datatype_info";
dataAdapter.Fill(dataSet, "DataTypes");
Console.WriteLine("Loading columns...");
dataAdapter.SelectCommand.CommandText = "exec sp_Columns @table_name='%'";
dataAdapter.Fill(dataSet, "Columns");
Console.WriteLine("Loading primary keys...");
dataAdapter.SelectCommand.CommandText = SqlStrings.PrimaryKeysQuery;
dataAdapter.Fill(dataSet, "PrimaryKeys");
Console.WriteLine("Loading foreign keys...");
dataAdapter.SelectCommand.CommandText = SqlStrings.ForeignKeysQuery;
dataAdapter.Fill(dataSet, "ForeignKeys");
}
SchemaInfo si = new SchemaInfo();
foreach (DataRow dr in dataSet.Tables["Tables"].Rows)
{
DumpTable(si, (string)dr["TABLE_OWNER"], (string)dr["TABLE_NAME"]);
}
DumpForeignKeys(si);
if (_haveIdentityColumns)
Console.WriteLine("WARNING: Identity columns are not supported. Sooda will not use them, but will provide its own pre-generated key.");
return si;
}
public void GenerateDatabaseSchema(CodeNamespace nspace, SchemaInfo schema)
{
CDILContext context = new CDILContext();
context["OutNamespace"] = Project.OutputNamespace;
CodeTypeDeclaration databaseSchemaClass = CDILParser.ParseClass(CDILTemplate.Get("DatabaseSchema.cdil"), context);
CodeArrayCreateExpression cace = new CodeArrayCreateExpression("ISoodaObjectFactory");
OutputFactories(cace, Project.OutputNamespace, schema);
CodeTypeConstructor ctc = new CodeTypeConstructor();
ctc.Statements.Add(
new CodeAssignStatement(
new CodeFieldReferenceExpression(null, "_theSchema"),
new CodeMethodInvokeExpression(null,"LoadSchema")));
databaseSchemaClass.Members.Add(ctc);
CodeConstructor ctor = new CodeConstructor();
ctor.Attributes = MemberAttributes.Public;
ctor.Statements.Add(
new CodeAssignStatement(
new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "_factories"), cace));
databaseSchemaClass.Members.Add(ctor);
nspace.Types.Add(databaseSchemaClass);
}
private void OutputFactories(CodeArrayCreateExpression cace, string ns, SchemaInfo schema)
{
//foreach (IncludeInfo ii in schema.Includes)
//{
// if ((ii.Schema != null) && (ii.AssemblyName != null) && (ii.AssemblyName != ""))
// OutputFactories(cace, ii.Namespace, ii.Schema);
//}
foreach (ClassInfo ci in schema.Classes)
{
string nameSpace = string.IsNullOrEmpty(ci.Schema.Namespace) ? ns : ci.Schema.Namespace;
cace.Initializers.Add(new CodePropertyReferenceExpression(new CodeTypeReferenceExpression(nameSpace + ".Stubs." + ci.Name + "_Factory"), "TheFactory"));
}
}
public void Include(SchemaInfo schema)
{
}
public override IDataReader LoadMatchingPrimaryKeys(SchemaInfo schemaInfo, ClassInfo classInfo, SoodaWhereClause whereClause, SoodaOrderBy orderBy, int startIdx, int pageCount)
{
try
{
SoqlQueryExpression queryExpression = new SoqlQueryExpression();
foreach (FieldInfo fi in classInfo.GetPrimaryKeyFields())
{
queryExpression.SelectExpressions.Add(new SoqlPathExpression(fi.Name));
queryExpression.SelectAliases.Add("");
}
if (schemaInfo.GetSubclasses(classInfo).Count > 0)
{
queryExpression.SelectExpressions.Add(new SoqlPathExpression(classInfo.SubclassSelectorField.Name));
queryExpression.SelectAliases.Add("");
}
queryExpression.StartIdx = startIdx;
queryExpression.PageCount = pageCount;
queryExpression.From.Add(classInfo.Name);
queryExpression.FromAliases.Add("");
if (whereClause != null && whereClause.WhereExpression != null)
{
queryExpression.WhereClause = whereClause.WhereExpression;
}
if (orderBy != null)
{
queryExpression.SetOrderBy(orderBy);
}
string query = SoqlToSql(queryExpression, schemaInfo, false);
IDbCommand cmd = Connection.CreateCommand();
try
{
cmd.CommandTimeout = CommandTimeout;
}
catch (NotSupportedException e)
{
logger.Debug("CommandTimeout not supported. {0}", e.Message);
}
if (Transaction != null)
cmd.Transaction = this.Transaction;
SqlBuilder.BuildCommandWithParameters(cmd, false, query, whereClause.Parameters, false);
return TimedExecuteReader(cmd);
}
catch (Exception ex)
{
logger.Error("Exception in LoadMatchingPrimaryKeys: {0}", ex);
throw;
}
}
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 MergeIncludedSchema(SchemaInfo includedSchema)
{
// merge classes, relations and datasources
if (includedSchema.Classes != null)
{
Dictionary <string, ClassInfo> classNames = new Dictionary <string, ClassInfo>();
foreach (ClassInfo nci in includedSchema.Classes)
{
classNames.Add(nci.Name, nci);
}
List <ClassInfo> newClasses = new List <ClassInfo>();
if (this.Classes != null)
{
foreach (ClassInfo ci in this.Classes)
{
newClasses.Add(ci);
ClassInfo ci2;
if (classNames.TryGetValue(ci.Name, out ci2))
{
ci.Merge(ci2);
classNames.Remove(ci.Name);
}
}
}
foreach (ClassInfo ci in classNames.Values)
{
newClasses.Add(ci);
}
this.Classes = newClasses;
}
if (includedSchema.Relations != null)
{
List <RelationInfo> newRelations = new List <RelationInfo>();
foreach (RelationInfo ci in includedSchema.Relations)
{
newRelations.Add(ci);
}
if (this.Relations != null)
{
foreach (RelationInfo ci in this.Relations)
{
newRelations.Add(ci);
}
}
this.Relations = newRelations;
}
if (includedSchema.DataSources != null)
{
Dictionary <string, DataSourceInfo> sourceNames = new Dictionary <string, DataSourceInfo>();
List <DataSourceInfo> newDataSources = new List <DataSourceInfo>();
if (this.DataSources != null)
{
foreach (DataSourceInfo ci in this.DataSources)
{
newDataSources.Add(ci);
sourceNames.Add(ci.Name, ci);
}
}
foreach (DataSourceInfo ci in includedSchema.DataSources)
{
DataSourceInfo di;
if (sourceNames.TryGetValue(ci.Name, out di))
{
di.EnableDynamicFields |= ci.EnableDynamicFields;
}
else
{
newDataSources.Add(ci);
}
}
this.DataSources = newDataSources;
}
}
public void Include(SchemaInfo schema)
{
}
public StringCollection GetBackRefCollections(SchemaInfo schema)
{
return schema.GetBackRefCollections(this);
}
private void RemoveReferencePrimaryKeys(SchemaInfo si)
{
// for classes, primary keys which are references are not supported
foreach (ClassInfo ci in si.Classes)
{
foreach (FieldInfo fi in ci.UnifiedFields)
{
if (fi.IsPrimaryKey)
fi.References = null;
}
}
}
private void AutoDetectRelations(SchemaInfo si)
{
foreach (ClassInfo ci in new ArrayList(si.Classes))
{
if (ci.LocalTables[0].Fields.Count != 2)
continue;
if (!(ci.LocalTables[0].Fields[0].IsPrimaryKey && ci.LocalTables[0].Fields[1].IsPrimaryKey))
continue;
if (ci.LocalTables[0].Fields[0].References == null || ci.LocalTables[0].Fields[1].References == null)
continue;
RelationInfo ri = new RelationInfo();
ri.Name = ci.Name;
ri.Table.DBTableName = ci.LocalTables[0].DBTableName;
ri.Table.Fields.Add(ci.LocalTables[0].Fields[0]);
ri.Table.Fields.Add(ci.LocalTables[0].Fields[1]);
si.Relations.Add(ri);
Console.WriteLine("Converting {0} to a relation", ci.Name);
si.Classes.Remove(ci);
}
}
private void AutoDetectCollections(SchemaInfo si)
{
int counter = 0;
foreach (ClassInfo ci in si.Classes)
{
foreach (FieldInfo fi in ci.LocalTables[0].Fields)
{
if (fi.ReferencedClass != null)
{
ArrayList al = new ArrayList();
if (fi.ReferencedClass.Collections1toN != null)
{
al.AddRange(fi.ReferencedClass.Collections1toN);
}
CollectionOnetoManyInfo coll = new CollectionOnetoManyInfo();
coll.Name = "CollectionOf" + ci.Name + "" + counter++;
coll.ClassName = ci.Name;
coll.ForeignFieldName = fi.Name;
al.Add(coll);
fi.ReferencedClass.Collections1toN = (CollectionOnetoManyInfo[])al.ToArray(typeof(CollectionOnetoManyInfo));
// ci.Collections1toN
}
}
}
foreach (RelationInfo ri in si.Relations)
{
CollectionManyToManyInfo mm;
ArrayList al;
al = new ArrayList();
if (ri.Table.Fields[0].ReferencedClass.CollectionsNtoN != null)
al.AddRange(ri.Table.Fields[0].ReferencedClass.CollectionsNtoN);
mm = new CollectionManyToManyInfo();
mm.Name = "CollectionOf" + ri.Table.Fields[1].ReferencedClass.Name + "" + counter++;
mm.Relation = ri.Name;
mm.ForeignField = ri.Table.Fields[0].Name;
al.Add(mm);
ri.Table.Fields[0].ReferencedClass.CollectionsNtoN = (CollectionManyToManyInfo[])al.ToArray(typeof(CollectionManyToManyInfo));
al = new ArrayList();
if (ri.Table.Fields[1].ReferencedClass.CollectionsNtoN != null)
al.AddRange(ri.Table.Fields[1].ReferencedClass.CollectionsNtoN);
mm = new CollectionManyToManyInfo();
mm.Name = "CollectionOf" + ri.Table.Fields[0].ReferencedClass.Name + "" + al.Count;
mm.Relation = ri.Name;
mm.ForeignField = ri.Table.Fields[1].Name;
al.Add(mm);
ri.Table.Fields[1].ReferencedClass.CollectionsNtoN = (CollectionManyToManyInfo[])al.ToArray(typeof(CollectionManyToManyInfo));
}
}
public override IDataReader LoadRefObjectList(SchemaInfo schema, RelationInfo relationInfo, int masterColumn, object masterValue, out TableInfo[] tables)
{
try
{
if (masterColumn == 0)
tables = relationInfo.GetRef1ClassInfo().UnifiedTables[0].ArraySingleton;
else
tables = relationInfo.GetRef2ClassInfo().UnifiedTables[0].ArraySingleton;
string query = GetLoadRefObjectSelectStatement(relationInfo, masterColumn);
IDbCommand cmd = Connection.CreateCommand();
try
{
cmd.CommandTimeout = CommandTimeout;
}
catch (NotSupportedException e)
{
logger.Debug("CommandTimeout not supported. {0}", e.Message);
}
if (Transaction != null)
cmd.Transaction = this.Transaction;
SqlBuilder.BuildCommandWithParameters(cmd, false, query, new object[] { masterValue }, false);
return TimedExecuteReader(cmd);
}
catch (Exception ex)
{
logger.Error("Exception in LoadRefObjectList: {0}", ex);
throw;
}
}
public override IDataReader ExecuteQuery(Sooda.QL.SoqlQueryExpression query, SchemaInfo schema, object[] parameters)
{
try
{
string queryText = SoqlToSql(query, schema, false);
return ExecuteRawQuery(queryText, parameters);
}
catch (Exception ex)
{
logger.Error("Exception in ExecuteQuery: {0}", ex);
throw;
}
}
public override IDataReader LoadObjectList(SchemaInfo schemaInfo, ClassInfo classInfo, SoodaWhereClause whereClause, SoodaOrderBy orderBy, int startIdx, int pageCount, SoodaSnapshotOptions options, out TableInfo[] tables)
{
try
{
Queue<_QueueItem> queue = new Queue<_QueueItem>();
List<TableInfo> tablesArrayList = new List<TableInfo>(classInfo.UnifiedTables.Count);
SoqlQueryExpression queryExpression = new SoqlQueryExpression();
queryExpression.StartIdx = startIdx;
queryExpression.PageCount = pageCount;
queryExpression.From.Add(classInfo.Name);
queryExpression.FromAliases.Add("");
foreach (TableInfo ti in classInfo.UnifiedTables)
{
tablesArrayList.Add(ti);
foreach (FieldInfo fi in ti.Fields)
{
SoqlPathExpression pathExpr = new SoqlPathExpression(fi.Name);
queryExpression.SelectExpressions.Add(pathExpr);
queryExpression.SelectAliases.Add("");
if (fi.ReferencedClass != null && fi.PrefetchLevel > 0 && ((options & SoodaSnapshotOptions.PrefetchRelated) != 0))
{
_QueueItem item = new _QueueItem();
item.classInfo = fi.ReferencedClass;
item.level = fi.PrefetchLevel;
item.prefix = pathExpr;
queue.Enqueue(item);
}
}
}
while (queue.Count > 0)
{
_QueueItem it = queue.Dequeue();
foreach (TableInfo ti in it.classInfo.UnifiedTables)
{
tablesArrayList.Add(ti);
foreach (FieldInfo fi in ti.Fields)
{
// TODO - this relies on the fact that path expressions
// are never reconstructed or broken. We simply share previous prefix
// perhaps it's cleaner to Clone() the expression here
SoqlPathExpression extendedExpression = new SoqlPathExpression(it.prefix, fi.Name);
queryExpression.SelectExpressions.Add(extendedExpression);
queryExpression.SelectAliases.Add("");
if (it.level >= 1 && fi.PrefetchLevel > 0 && fi.ReferencedClass != null)
{
_QueueItem newItem = new _QueueItem();
newItem.classInfo = fi.ReferencedClass;
newItem.prefix = extendedExpression;
newItem.level = it.level - 1;
queue.Enqueue(newItem);
}
}
}
}
if (whereClause != null && whereClause.WhereExpression != null)
{
queryExpression.WhereClause = whereClause.WhereExpression;
}
if (orderBy != null)
{
queryExpression.SetOrderBy(orderBy);
}
string query = SoqlToSql(queryExpression, schemaInfo, false);
IDbCommand cmd = Connection.CreateCommand();
try
{
cmd.CommandTimeout = CommandTimeout;
}
catch (NotSupportedException e)
{
logger.Debug("CommandTimeout not supported. {0}", e.Message);
}
if (Transaction != null)
cmd.Transaction = this.Transaction;
SqlBuilder.BuildCommandWithParameters(cmd, false, query, whereClause.Parameters, false);
tables = tablesArrayList.ToArray();
return TimedExecuteReader(cmd);
}
catch (Exception ex)
{
logger.Error("Exception in LoadObjectList: {0}", ex);
throw;
}
}
static bool DynamicFieldsEnabled(SchemaInfo schema)
{
return(schema.DataSources.Any(ds => ds.EnableDynamicFields));
}
public StringCollection GetBackRefCollections(SchemaInfo schema)
{
return(schema.GetBackRefCollections(this));
}
internal void ResolveReferences(SchemaInfo schema)
{
if (References == null)
return;
ClassInfo ci = schema.FindClassByName(References);
if (ci == null)
throw new SoodaSchemaException("Class " + References + " not found.");
DataType = ci.GetFirstPrimaryKeyField().DataType;
ReferencedClass = ci;
}
internal void MergeIncludedSchema(SchemaInfo includedSchema)
{
// merge classes, relations and datasources
if (includedSchema.Classes != null)
{
Dictionary<string, ClassInfo> classNames = new Dictionary<string, ClassInfo>();
foreach (ClassInfo nci in includedSchema.Classes)
classNames.Add(nci.Name, nci);
List<ClassInfo> newClasses = new List<ClassInfo>();
if (this.Classes != null)
{
foreach (ClassInfo ci in this.Classes)
{
newClasses.Add(ci);
ClassInfo ci2;
if (classNames.TryGetValue(ci.Name, out ci2))
{
ci.Merge(ci2);
classNames.Remove(ci.Name);
}
}
}
foreach (ClassInfo ci in classNames.Values)
{
newClasses.Add(ci);
}
this.Classes = newClasses;
}
if (includedSchema.Relations != null)
{
List<RelationInfo> newRelations = new List<RelationInfo>();
foreach (RelationInfo ci in includedSchema.Relations)
{
newRelations.Add(ci);
}
if (this.Relations != null)
{
foreach (RelationInfo ci in this.Relations)
{
newRelations.Add(ci);
}
}
this.Relations = newRelations;
}
if (includedSchema.DataSources != null)
{
Dictionary<string, DataSourceInfo> sourceNames = new Dictionary<string, DataSourceInfo>();
List<DataSourceInfo> newDataSources = new List<DataSourceInfo>();
if (this.DataSources != null)
{
foreach (DataSourceInfo ci in this.DataSources)
{
newDataSources.Add(ci);
sourceNames.Add(ci.Name, ci);
}
}
foreach (DataSourceInfo ci in includedSchema.DataSources)
{
DataSourceInfo di;
if (sourceNames.TryGetValue(ci.Name, out di))
di.EnableDynamicFields |= ci.EnableDynamicFields;
else
newDataSources.Add(ci);
}
this.DataSources = newDataSources;
}
}
public virtual void GenerateDdlForSchema(SchemaInfo schema, TextWriter tw)
{
Dictionary<string, TableInfo> tables = new Dictionary<string, TableInfo>();
Dictionary<string, string> processed = new Dictionary<string, string>();
while (processed.Count < schema.Classes.Count)
{
foreach (ClassInfo ci in schema.Classes)
{
if (!processed.ContainsKey(ci.Name))
{
bool isInherited = ci.InheritsFromClass != null;
if (!isInherited || processed.ContainsKey(ci.InheritsFromClass.Name))
{
foreach (TableInfo ti in ci.UnifiedTables)
{
UnifyTable(tables, ti, isInherited);
}
processed.Add(ci.Name, ci.Name);
}
}
}
}
foreach (RelationInfo ri in schema.Relations)
{
UnifyTable(tables, ri.Table, false);
}
List<string> names = new List<string>();
foreach (TableInfo ti in tables.Values)
{
names.Add(ti.DBTableName);
}
names.Sort();
foreach (string s in names)
{
tw.WriteLine("--- table {0}", s);
SqlBuilder.GenerateCreateTable(tw, tables[s], this.CreateTable, null);
}
foreach (string s in names)
{
SqlBuilder.GeneratePrimaryKey(tw, tables[s], this.CreateIndex, null);
}
foreach (string s in names)
{
SqlBuilder.GenerateForeignKeys(tw, tables[s], null);
}
foreach (string s in names)
{
SqlBuilder.GenerateIndices(tw, tables[s], this.CreateIndex, null);
}
if (schema.GetDataSourceInfo(Name).EnableDynamicFields)
SqlBuilder.GenerateSoodaDynamicField(tw, null);
}
private void DumpForeignKeys(SchemaInfo schemaInfo)
{
DataRow[] fkeys = dataSet.Tables["ForeignKeys"].Select("1=1", "SOURCE_TABLE_NAME, FKEY_NAME");
for (int i = 0; i < fkeys.Length; ++i)
{
DataRow r = fkeys[i];
string curSrcTableOwner = r["SOURCE_TABLE_OWNER"].ToString();
string curSrcTableName = r["SOURCE_TABLE_NAME"].ToString();
string curSrcColumnName = r["SOURCE_COLUMN_NAME"].ToString();
string curDstTableOwner = r["DEST_TABLE_OWNER"].ToString();
string curDstTableName = r["DEST_TABLE_NAME"].ToString();
string curDstColumnName = r["DEST_COLUMN_NAME"].ToString();
foreach (ClassInfo sourceTable in schemaInfo.Classes)
{
if (sourceTable.LocalTables[0].DBTableName == curSrcTableName)
{
foreach (FieldInfo fi in sourceTable.LocalTables[0].Fields)
{
if (fi.DBColumnName == curSrcColumnName)
{
fi.References = MakePascalCase(curDstTableName);
break;
}
}
}
}
}
}
internal void ResolveInheritance(SchemaInfo schema)
{
if (InheritFrom != null)
{
InheritsFromClass = schema.FindClassByName(InheritFrom);
}
else
{
InheritsFromClass = null;
}
}
internal void ResolveCollections(SchemaInfo schema)
{
if (CollectionsNtoN != null)
{
foreach (CollectionManyToManyInfo cinfo in CollectionsNtoN)
{
cinfo.Resolve(schema);
}
}
if (Collections1toN != null)
{
foreach (CollectionOnetoManyInfo cinfo in Collections1toN)
{
ClassInfo ci = schema.FindClassByName(cinfo.ClassName);
if (ci == null)
throw new SoodaSchemaException("Collection " + Name + "." + cinfo.Name + " cannot find class " + cinfo.ClassName);
FieldInfo fi = ci.FindFieldByName(cinfo.ForeignFieldName);
if (fi == null)
throw new SoodaSchemaException("Collection " + Name + "." + cinfo.Name + " cannot find field " + cinfo.ClassName + "." + cinfo.ForeignFieldName);
schema.AddBackRefCollection(fi, cinfo.Name);
cinfo.ForeignField2 = fi;
cinfo.Class = ci;
}
}
}
private string SoqlToSql(SoqlQueryExpression queryExpression, SchemaInfo schemaInfo, bool generateColumnAliases)
{
StringWriter sw = new StringWriter();
SoqlToSqlConverter converter = new SoqlToSqlConverter(sw, schemaInfo, SqlBuilder);
converter.IndentOutput = this.IndentQueries;
converter.GenerateColumnAliases = generateColumnAliases;
converter.UpperLike = this.UpperLike;
//logger.Trace("Converting {0}", queryExpression);
converter.ConvertQuery(queryExpression);
string query = sw.ToString();
//logger.Trace("Converted as {0}", query);
return query;
}
public List<ClassInfo> GetSubclassesForSchema(SchemaInfo schema)
{
return schema.GetSubclasses(this);
}
public void Run()
{
try
{
if (Project.SchemaFile == null)
throw new SoodaCodeGenException("No schema file specified.");
if (Project.OutputPath == null)
throw new SoodaCodeGenException("No Output path specified.");
if (Project.OutputNamespace == null)
throw new SoodaCodeGenException("No Output namespace specified.");
CodeDomProvider codeProvider = GetCodeProvider(Project.Language);
_codeProvider = codeProvider;
CodeDomProvider codeGenerator = codeProvider;
CodeDomProvider csharpCodeGenerator = GetCodeProvider("c#");
_codeGenerator = codeGenerator;
_csharpCodeGenerator = csharpCodeGenerator;
_fileExtensionWithoutPeriod = _codeProvider.FileExtension;
if (_fileExtensionWithoutPeriod.StartsWith("."))
_fileExtensionWithoutPeriod = _fileExtensionWithoutPeriod.Substring(1);
Output.Verbose("Loading schema file {0}...", Project.SchemaFile);
_schema = SchemaManager.ReadAndValidateSchema(
new XmlTextReader(Project.SchemaFile),
Path.GetDirectoryName(Project.SchemaFile)
);
if (string.IsNullOrEmpty(_schema.Namespace))
_schema.Namespace = Project.OutputNamespace;
StringCollection inputFiles = new StringCollection();
StringCollection rewrittenOutputFiles = new StringCollection();
StringCollection shouldBePresentOutputFiles = new StringCollection();
GetInputAndOutputFiles(inputFiles, rewrittenOutputFiles, shouldBePresentOutputFiles);
bool doRebuild = false;
if (MinDate(shouldBePresentOutputFiles) == DateTime.MaxValue)
doRebuild = true;
if (MaxDate(inputFiles) > MinDate(rewrittenOutputFiles))
doRebuild = true;
if (!RebuildIfChanged)
doRebuild = true;
if (RewriteProjects)
doRebuild = true;
if (!doRebuild)
{
Output.Info("Not rebuilding.");
return;
}
/*
foreach (string s in inputFiles)
{
Output.Verbose("IN: {0}", s);
}
foreach (string s in outputFiles)
{
Output.Verbose("OUT: {0}", s);
}
*/
if (Project.AssemblyName == null)
Project.AssemblyName = Project.OutputNamespace;
Output.Verbose("Loaded {0} classes, {1} relations...", _schema.LocalClasses.Count, _schema.Relations.Count);
LoadExternalProjects();
CreateOutputDirectories(rewrittenOutputFiles);
CreateOutputDirectories(shouldBePresentOutputFiles);
string stubsFileName;
Output.Verbose("CodeProvider: {0}", codeProvider.GetType().FullName);
Output.Verbose("Source extension: {0}", codeProvider.FileExtension);
foreach (ExternalProjectInfo epi in Project.ExternalProjects)
{
Output.Verbose("Project: {0} ({1})", epi.ProjectType, epi.ActualProjectFile);
}
Output.Verbose("Output Path: {0}", Project.OutputPath);
Output.Verbose("Namespace: {0}", Project.OutputNamespace);
// write skeleton files
_codeGeneratorOptions = new CodeGeneratorOptions();
_codeGeneratorOptions.BracingStyle = "C";
_codeGeneratorOptions.IndentString = " ";
WriteSkeletonClasses();
// write stubs
_codeGeneratorOptions.BracingStyle = "Block";
_codeGeneratorOptions.IndentString = " ";
_codeGeneratorOptions.BlankLinesBetweenMembers = false;
if (Project.SeparateStubs)
{
WriteMiniSkeleton();
WriteMiniStubs();
}
SerializeSchema();
// codeGenerator = csharpCodeGenerator;
if (Project.SeparateStubs)
{
stubsFileName = Path.Combine(Project.OutputPath, "Stubs/_Stubs.csx");
}
else if (Project.FilePerNamespace)
{
string fname = "_Stubs." + _fileExtensionWithoutPeriod;
stubsFileName = Path.Combine(Project.OutputPath, fname);
foreach (ExternalProjectInfo epi in Project.ExternalProjects)
{
epi.ProjectProvider.AddCompileUnit(fname);
}
fname = "_Stubs." + Project.OutputNamespace + ".TypedQueries." + _fileExtensionWithoutPeriod;
foreach (ExternalProjectInfo epi in Project.ExternalProjects)
{
epi.ProjectProvider.AddCompileUnit(fname);
}
fname = "_Stubs." + Project.OutputNamespace + ".Stubs." + _fileExtensionWithoutPeriod;
foreach (ExternalProjectInfo epi in Project.ExternalProjects)
{
epi.ProjectProvider.AddCompileUnit(fname);
}
}
else
{
string fname = "_Stubs." + _fileExtensionWithoutPeriod;
foreach (ExternalProjectInfo epi in Project.ExternalProjects)
{
epi.ProjectProvider.AddCompileUnit(fname);
}
stubsFileName = Path.Combine(Project.OutputPath, fname);
}
CodeCompileUnit ccu = new CodeCompileUnit();
CodeAttributeDeclaration cad = new CodeAttributeDeclaration("Sooda.SoodaObjectsAssembly");
cad.Arguments.Add(new CodeAttributeArgument(new CodeTypeOfExpression(Project.OutputNamespace + "._DatabaseSchema")));
ccu.AssemblyCustomAttributes.Add(cad);
CodeNamespace nspace = null;
if (Project.WithSoql || Project.LoaderClass)
{
nspace = CreateBaseNamespace(_schema);
ccu.Namespaces.Add(nspace);
}
if (Project.WithSoql)
{
Output.Verbose(" * list wrappers");
foreach (ClassInfo ci in _schema.LocalClasses)
{
GenerateListWrapper(nspace, ci);
}
}
if (Project.LoaderClass)
{
Output.Verbose(" * loader class");
foreach (ClassInfo ci in _schema.LocalClasses)
{
GenerateLoaderClass(nspace, ci);
}
}
Output.Verbose(" * database schema");
// stubs namespace
nspace = CreateStubsNamespace(_schema);
ccu.Namespaces.Add(nspace);
Output.Verbose(" * class stubs");
foreach (ClassInfo ci in _schema.LocalClasses)
{
GenerateClassStub(nspace, ci, false);
}
Output.Verbose(" * class factories");
foreach (ClassInfo ci in _schema.LocalClasses)
{
GenerateClassFactory(nspace, ci);
}
Output.Verbose(" * N-N relation stubs");
foreach (RelationInfo ri in _schema.LocalRelations)
{
GenerateRelationStub(nspace, ri);
}
if (Project.WithTypedQueryWrappers)
{
Output.Verbose(" * typed query wrappers (internal)");
foreach (ClassInfo ci in _schema.LocalClasses)
{
GenerateTypedInternalQueryWrappers(nspace, ci);
}
nspace = CreateTypedQueriesNamespace(_schema);
ccu.Namespaces.Add(nspace);
Output.Verbose(" * typed query wrappers");
foreach (ClassInfo ci in _schema.LocalClasses)
{
GenerateTypedPublicQueryWrappers(nspace, ci);
}
}
if (Project.FilePerNamespace)
{
foreach (CodeNamespace ns in ccu.Namespaces)
{
using (StringWriter sw = new StringWriter())
{
Output.Verbose("Writing code...");
codeGenerator.GenerateCodeFromNamespace(ns, sw, _codeGeneratorOptions);
Output.Verbose("Done.");
string resultString = sw.ToString();
resultString = resultString.Replace("[System.ParamArrayAttribute()] ", "params ");
string fileName = "_Stubs." + ns.Name + "." + _fileExtensionWithoutPeriod;
foreach (ExternalProjectInfo epi in Project.ExternalProjects)
{
epi.ProjectProvider.AddCompileUnit(fileName);
}
using (TextWriter tw = new StreamWriter(Path.Combine(Project.OutputPath, fileName)))
{
tw.Write(resultString);
}
}
}
ccu.Namespaces.Clear();
}
nspace = CreateBaseNamespace(_schema);
ccu.Namespaces.Add(nspace);
GenerateDatabaseSchema(nspace, _schema);
using (StringWriter sw = new StringWriter())
{
Output.Verbose("Writing code...");
codeGenerator.GenerateCodeFromCompileUnit(ccu, sw, _codeGeneratorOptions);
Output.Verbose("Done.");
string resultString = sw.ToString();
resultString = resultString.Replace("[System.ParamArrayAttribute()] ", "params ");
using (TextWriter tw = new StreamWriter(stubsFileName))
{
tw.Write(resultString);
}
}
SaveExternalProjects();
return;
}
catch (SoodaCodeGenException e)
{
throw e;
}
catch (SoodaSchemaException e)
{
throw new SoodaCodeGenException("Schema validation error.", e);
}
catch (ApplicationException e)
{
throw new SoodaCodeGenException("Error generating code.", e);
}
catch (Exception e)
{
throw new SoodaCodeGenException("Unexpected error.", e);
}
}
internal void Resolve(SchemaInfo schema)
{
if (parentSchema == null)
parentSchema = schema;
OuterReferences = new List<FieldInfo>();
// local fields - a sum of all tables local to the class
LocalFields = new List<FieldInfo>();
int localOrdinal = 0;
int count = 0;
foreach (TableInfo table in LocalTables)
{
foreach (FieldInfo fi in table.Fields)
{
// add all fields from the root table + all non-key fields
// from other tables
if (table.OrdinalInClass == 0 || !fi.IsPrimaryKey)
{
// Console.WriteLine("Adding local field {0} to class {1}", fi.Name, Name);
LocalFields.Add(fi);
fi.ClassLocalOrdinal = localOrdinal++;
}
}
count++;
}
if (SubclassSelectorFieldName == null && InheritsFromClass != null)
{
for (ClassInfo ci = this; ci != null; ci = ci.InheritsFromClass)
{
if (ci.SubclassSelectorFieldName != null)
{
SubclassSelectorFieldName = ci.SubclassSelectorFieldName;
break;
}
}
}
UnifiedCollections = new List<CollectionBaseInfo>();
LocalCollections = new List<CollectionBaseInfo>();
for (ClassInfo ci = this; ci != null; ci = ci.InheritsFromClass)
{
if (ci.Collections1toN != null)
{
foreach (CollectionOnetoManyInfo c in ci.Collections1toN)
{
UnifiedCollections.Add(c);
if (ci == this)
LocalCollections.Add(c);
}
}
if (ci.CollectionsNtoN != null)
{
foreach (CollectionManyToManyInfo c in ci.CollectionsNtoN)
{
UnifiedCollections.Add(c);
if (ci == this)
LocalCollections.Add(c);
}
}
}
// all inherited fields + local fields
UnifiedFields = new List<FieldInfo>();
int unifiedOrdinal = 0;
foreach (TableInfo ti in UnifiedTables)
{
foreach (FieldInfo fi in ti.Fields)
{
if (ti.OrdinalInClass == 0 || !fi.IsPrimaryKey)
{
UnifiedFields.Add(fi);
fi.ClassUnifiedOrdinal = unifiedOrdinal++;
}
}
}
_orderedFieldNames = new string[UnifiedFields.Count];
for (int i = 0; i < UnifiedFields.Count; ++i)
{
_orderedFieldNames[i] = UnifiedFields[i].Name;
}
if (SubclassSelectorFieldName != null)
{
SubclassSelectorField = FindFieldByName(SubclassSelectorFieldName);
if (SubclassSelectorField == null)
throw new SoodaSchemaException("subclassSelectorField points to invalid field name " + SubclassSelectorFieldName + " in " + Name);
}
else if (InheritFrom != null)
{
throw new SoodaSchemaException(String.Format("Must use subclassSelectorFieldName when defining inherited class '{0}'", this.Name));
}
if (SubclassSelectorStringValue != null)
{
// TODO - allow other types based on the field type
//
if (SubclassSelectorField == null)
throw new SoodaSchemaException("subclassSelectorField is invalid");
switch (SubclassSelectorField.DataType)
{
case FieldDataType.Integer:
SubclassSelectorValue = Convert.ToInt32(SubclassSelectorStringValue);
break;
case FieldDataType.String:
SubclassSelectorValue = SubclassSelectorStringValue;
break;
default:
throw new SoodaSchemaException("Field data type not supported for subclassSelectorValue: " + SubclassSelectorField.DataType);
}
}
List<FieldInfo> pkFields = new List<FieldInfo>();
foreach (FieldInfo fi in UnifiedFields)
{
if (fi.IsPrimaryKey)
pkFields.Add(fi);
}
_primaryKeyFields = pkFields.ToArray();
}
CodeNamespace CreatePartialNamespace(SchemaInfo schema)
{
CodeNamespace nspace = new CodeNamespace(Project.OutputNamespace);
return nspace;
}
internal void ResolveReferences(SchemaInfo schema)
{
// logger.Debug("ResolveReferences({0})", this.Name);
foreach (FieldInfo fi in UnifiedFields)
{
// logger.Debug("unifiedField: {0}", fi.Name);
fi.ResolveReferences(schema);
}
foreach (FieldInfo fi in LocalFields)
{
fi.ParentClass = this;
// logger.Debug("localField: {0}", fi.Name);
if (fi.ReferencedClass != null)
{
// logger.Debug("Is a reference to {0} with ondelete = {1}", fi.ReferencedClass.Name, fi.DeleteAction);
fi.ReferencedClass.OuterReferences.Add(fi);
}
}
}
CodeNamespace CreateStubsNamespace(SchemaInfo schema)
{
CodeNamespace nspace = new CodeNamespace(Project.OutputNamespace + ".Stubs");
nspace.Imports.Add(new CodeNamespaceImport("System"));
nspace.Imports.Add(new CodeNamespaceImport("System.Collections"));
nspace.Imports.Add(new CodeNamespaceImport("System.Diagnostics"));
nspace.Imports.Add(new CodeNamespaceImport("System.Data"));
nspace.Imports.Add(new CodeNamespaceImport("Sooda"));
nspace.Imports.Add(new CodeNamespaceImport("Sooda.ObjectMapper"));
nspace.Imports.Add(new CodeNamespaceImport(Project.OutputNamespace.Replace(".", "") + " = " + Project.OutputNamespace));
AddImportsFromIncludedSchema(nspace, schema.Includes, false);
AddImportsFromIncludedSchema(nspace, schema.Includes, true);
return nspace;
}
