private IEnumerable <ExplorerItem> GetParams(SchemaObject o) { return(from p in o.Parameters select new ExplorerItem(p.ClrName + " (" + p.ClrType.FormatTypeName() + ")", ExplorerItemKind.Parameter, ExplorerIcon.Parameter) { DragText = p.ClrName, SqlName = p.ParamName }); }
private List <ExplorerItem> GetChildItems(SchemaObject o, bool isSqlServer) { IEnumerable <ExplorerItem> first = Enumerable.Empty <ExplorerItem>(); if (o.Parameters.Count > 0) { first = first.Concat <ExplorerItem>(this.GetParams(o)); } first = first.Concat <ExplorerItem>(from col in o.ColumnsInOrder let text = col.PropertyName + " (" + col.ClrType.FormatTypeName() + ")" let sqlTypeDec = col.GetFullSqlTypeDeclaration() select new ExplorerItem(text, ExplorerItemKind.Property, col.IsKey ? ExplorerIcon.Key : ExplorerIcon.Column) { DragText = col.PropertyName, ToolTipText = (sqlTypeDec == null) ? null : (col.ColumnName + " " + sqlTypeDec), SqlName = col.ColumnName, SqlTypeDeclaration = sqlTypeDec }); Table t = o as Table; if (t != null) { IOrderedEnumerable <ExplorerItem> second = from a in this.GetParents(t).Concat <ExplorerItem>(this.GetChildren(t)) orderby a.Icon != ExplorerIcon.OneToOne select a; first = first.Concat <ExplorerItem>(second); if (!(t.HasKey || !isSqlServer)) { first = first.Concat <ExplorerItem>(new ExplorerItem[] { new ExplorerItem("(Warning: No primary key, updates will fail)", ExplorerItemKind.Property, ExplorerIcon.Inherited) }); } } return(first.ToList <ExplorerItem>()); }
public EntityCodeGen(bool singularize, SchemaObject schemaObject) : base(singularize) { if (schemaObject == null) { throw new ArgumentNullException("schemaObject"); } _schemaObject = schemaObject; }
private void ReadRoutineParameters(IEnumerable <Parameter> routineParameters) { if (routineParameters != null) { SchemaObject obj2 = null; string str = null; foreach (Parameter parameter in routineParameters) { string key = parameter.RoutineSchema + "." + parameter.RoutineName; if (key != str) { if (!this.Objects.TryGetValue(key, out obj2)) { obj2 = null; } str = key; } if (obj2 != null) { if (!parameter.IsValid) { this.Objects.Remove(key); } else if (parameter.IsResult) { obj2.ReturnInfo = parameter; } else { obj2.Parameters.Add(parameter); } } } foreach (SchemaObject obj3 in this.Objects.Values) { DotNetNameBank bank = new DotNetNameBank(); foreach (Parameter parameter2 in obj3.Parameters) { bank.RegisterName(parameter2.ParamName); } foreach (Parameter parameter2 in obj3.Parameters.ToArray <Parameter>()) { string uniqueDotNetName = bank.GetUniqueDotNetName(parameter2.ParamName); if (uniqueDotNetName == null) { obj2.Parameters.Remove(parameter2); } else { parameter2.ClrName = uniqueDotNetName; } } } } }
private static IDictionary<int, Column> GetColumns(SchemaObject schemaObject) { var table = schemaObject as Table; if (table != null) { return table.Columns; } var view = schemaObject as View; if (view != null) { return view.Columns; } return null; }
private void EmitCanonFunctionMethod(TypeBuilder dcType, string methName, MethodInfo parentMethod, Action<ILGenerator> dcFieldLoader, SchemaObject funcInfo) { if (parentMethod != null) { FunctionGenerator generator = new FunctionGenerator(this, dcType, funcInfo, methName, MethodAttributes.Public); if (generator.Method != null) { ILGenerator iLGenerator = generator.Method.GetILGenerator(); iLGenerator.Emit(OpCodes.Ldarg_0); dcFieldLoader(iLGenerator); int position = 0; foreach (Parameter parameter in funcInfo.Parameters) { position++; generator.Method.DefineParameter(position, ParameterAttributes.None, parameter.ClrName); iLGenerator.Emit(OpCodes.Ldarg, position); } iLGenerator.Emit(OpCodes.Call, parentMethod); iLGenerator.Emit(OpCodes.Ret); } } }
private MethodInfo EmitFunctionMethod(TypeBuilder dcType, string methName, SchemaObject funcInfo, string objectPrefix, MethodAttributes accessibility) { FunctionGenerator generator = new FunctionGenerator(this, dcType, funcInfo, methName, accessibility); if (generator.Method == null) { return null; } generator.AddAttributes(objectPrefix); ILGenerator iLGenerator = generator.Method.GetILGenerator(); LocalBuilder local = iLGenerator.DeclareLocal(typeof(object[])); iLGenerator.Emit(OpCodes.Ldarg_0); iLGenerator.Emit(OpCodes.Ldarg_0); iLGenerator.Emit(OpCodes.Call, typeof(MethodBase).GetMethod("GetCurrentMethod", BindingFlags.Public | BindingFlags.Static, null, Type.EmptyTypes, null)); iLGenerator.Emit(OpCodes.Castclass, typeof(MethodInfo)); iLGenerator.Emit(OpCodes.Ldc_I4, funcInfo.Parameters.Count); iLGenerator.Emit(OpCodes.Newarr, typeof(object)); iLGenerator.Emit(OpCodes.Stloc, local); int arg = 0; foreach (Parameter parameter in funcInfo.Parameters) { iLGenerator.Emit(OpCodes.Ldloc, local); iLGenerator.Emit(OpCodes.Ldc_I4, arg); iLGenerator.Emit(OpCodes.Ldarg, (int) (arg + 1)); if (parameter.ClrType.IsValueType) { iLGenerator.Emit(OpCodes.Box, parameter.ClrType); } iLGenerator.Emit(OpCodes.Stelem_Ref); arg++; } iLGenerator.Emit(OpCodes.Ldloc, local); MethodInfo meth = typeof(DataContext).GetMethod((funcInfo is TableFunction) ? "CreateMethodCallQuery" : "ExecuteMethodCall", BindingFlags.NonPublic | BindingFlags.Instance, null, new Type[] { typeof(object), typeof(MethodInfo), typeof(object[]) }, null); if (funcInfo is TableFunction) { meth = meth.MakeGenericMethod(new Type[] { generator.ResultType }); } iLGenerator.Emit(OpCodes.Call, meth); if (funcInfo is ScalarFunction) { iLGenerator.Emit(OpCodes.Callvirt, typeof(IExecuteResult).GetProperty("ReturnValue").GetGetMethod()); iLGenerator.Emit(generator.ResultType.IsValueType ? OpCodes.Unbox_Any : OpCodes.Castclass, generator.ResultType); } iLGenerator.Emit(OpCodes.Ret); return generator.Method; }
private void WriteColumns(SchemaObject schemaObject) { var columns = GetColumns(schemaObject); if (columns == null) { return; } foreach (var column in columns.Values.Cast<VfpColumn>()) { WriteTab(); Write("[Column(Member=\""); Write(column.PropertyName); Write("\""); if (!column.ColumnName.Equals(column.PropertyName, StringComparison.InvariantCultureIgnoreCase)) { Write(", Name=\""); Write(column.ColumnName); Write("\""); } if (column.IsKey) { Write(", IsPrimaryKey=true"); if (column.IsAutoGen) { Write(", IsGenerated=true"); } } if (!string.IsNullOrWhiteSpace(column.FieldType)) { Write(", DbType=\""); Write(column.FieldType); Write("\""); } WriteLine(")]"); } }
private void WriteAssociations(SchemaObject schemaObject) { var table = schemaObject as Table; if (table == null) { return; } WriteAssociations(table.ParentRelations, true); WriteAssociations(table.ChildRelations, false); }
private Type EmitTableClass(SchemaObject t, string objectPrefix) { TypeBuilder builder = this._tableTypes[t.DotNetName]; ConstructorInfo constructor = typeof(TableAttribute).GetConstructor(new Type[0]); PropertyInfo property = typeof(TableAttribute).GetProperty("Name"); string str = BracketsForSql((t.SchemaName == "dbo") ? "" : t.SchemaName); if ((objectPrefix.Length > 0) && (str.Length == 0)) { str = "[dbo]"; } string str2 = BracketsForSql(t.SqlName); if (str.Length > 0) { str2 = str + "." + str2; } str2 = objectPrefix + str2; CustomAttributeBuilder customBuilder = new CustomAttributeBuilder(constructor, new object[0], new PropertyInfo[] { property }, new object[] { str2 }); builder.SetCustomAttribute(customBuilder); ILGenerator iLGenerator = builder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, new Type[0]).GetILGenerator(); foreach (SqlColumn column in t.Columns.Values) { this.EmitColumn(builder, column); } Table table = t as Table; if (table != null) { foreach (Relationship relationship in table.ParentRelations) { this.EmitParentRelation(iLGenerator, builder, relationship); } foreach (Relationship relationship in table.ChildRelations) { if (relationship.IsOneToOne) { this.EmitOneToOneOnChildSide(iLGenerator, builder, relationship); } else { this.EmitChildRelation(iLGenerator, builder, relationship); } } } iLGenerator.Emit(OpCodes.Ret); return builder; }
private void EmitTableProperty(TypeBuilder dcType, Action<ILGenerator> dcFieldLoader, SchemaObject tableInfo) { Type type = this._tableTypes[tableInfo.DotNetName]; string propertyName = tableInfo.PropertyName; string name = "get_" + propertyName; Type returnType = typeof(Table<>).MakeGenericType(new Type[] { type }); PropertyBuilder builder = dcType.DefineProperty(propertyName, PropertyAttributes.None, returnType, new Type[0]); MethodBuilder mdBuilder = dcType.DefineMethod(name, MethodAttributes.SpecialName | MethodAttributes.Public, returnType, new Type[0]); MethodInfo meth = typeof(DataContext).GetMethod("GetTable", new Type[0]).MakeGenericMethod(new Type[] { type }); ILGenerator iLGenerator = mdBuilder.GetILGenerator(); iLGenerator.Emit(OpCodes.Ldarg_0); if (dcFieldLoader != null) { dcFieldLoader(iLGenerator); } iLGenerator.Emit(OpCodes.Call, meth); iLGenerator.Emit(OpCodes.Ret); builder.SetGetMethod(mdBuilder); }
private void ReadColumns(IEnumerable <Column> columns) { string str2; Dictionary <string, string> dictionary = new Dictionary <string, string>(); List <Column> list = new List <Column>(0x1000); foreach (Column column in columns) { string str; list.Add(column); if (dictionary.TryGetValue(column.ObjectName, out str)) { if ((str != null) && (str != column.SchemaName)) { dictionary[column.ObjectName] = null; } } else { dictionary.Add(column.ObjectName, column.SchemaName); } } DotNetNameBank bank = new DotNetNameBank(); foreach (Column column in list) { str2 = dictionary[column.ObjectName]; string sqlName = (((str2 != null) || (column.SchemaName == "dbo")) || (column.SchemaName == "")) ? column.ObjectName : (column.SchemaName + "_" + column.ObjectName); bank.RegisterName(sqlName); } HashSet <string> set = new HashSet <string>(); foreach (Column column in list) { if (dictionary.TryGetValue(column.ObjectName, out str2)) { string str4 = (((str2 != null) || (column.SchemaName == "dbo")) || (column.SchemaName == "")) ? column.ObjectName : (column.SchemaName + "_" + column.ObjectName); string uniqueDotNetName = bank.GetUniqueDotNetName(str4); if (uniqueDotNetName != null) { if ((column.ObjectKind == DbObjectKind.Table) || (column.ObjectKind == DbObjectKind.View)) { uniqueDotNetName = this.TransformIdentifier(uniqueDotNetName); } string key = column.SchemaName + "." + column.ObjectName; if (!this.Objects.ContainsKey(key)) { if (set.Contains(uniqueDotNetName)) { continue; } set.Add(uniqueDotNetName); SchemaObject obj2 = SchemaObject.Create(column, uniqueDotNetName); this.Objects.Add(key, obj2); } SchemaObject obj3 = this.Objects[key]; if (column.IsKey) { obj3.HasKey = true; } column.ClrObjectName = uniqueDotNetName; column.Object = obj3; obj3.Columns[column.ColumnID] = column; } } } foreach (SchemaObject obj2 in this.Objects.Values) { obj2.OriginalName = obj2.PropertyName; if (this.Pluralize && obj2.IsPluralizable) { string pluralName = StringUtil.GetPluralName(obj2.PropertyName); if (!set.Contains(pluralName)) { obj2.PropertyName = pluralName; } } } }
protected string GetEntityClassName(SchemaObject schemaObject) { return _singularize ? _pluralizationService.Singularize(schemaObject.DotNetName) : schemaObject.DotNetName; }
private void EmitStoredProc(TypeBuilder dcType, Action<ILGenerator> dcFieldLoader, SchemaObject procInfo, string objectPrefix, bool useOptional) { Func<Parameter, Type> func; if (useOptional) { func = p => typeof(Optional<>).MakeGenericType(new Type[] { p.ClrType }); } else { func = p => p.ClrType; } MethodBuilder builder = dcType.DefineMethod(procInfo.PropertyName, MethodAttributes.Public, typeof(ReturnDataSet), procInfo.Parameters.Select<Parameter, Type>(func).ToArray<Type>()); ParameterAttributes attributes = useOptional ? (ParameterAttributes.HasDefault | ParameterAttributes.Optional) : ParameterAttributes.None; int arg = 1; foreach (Parameter parameter in procInfo.Parameters) { builder.DefineParameter(arg++, attributes, parameter.ClrName); } ILGenerator iLGenerator = builder.GetILGenerator(); LocalBuilder local = iLGenerator.DeclareLocal(typeof(object[])); iLGenerator.Emit(OpCodes.Ldarg_0); if (dcFieldLoader != null) { dcFieldLoader(iLGenerator); } iLGenerator.Emit(OpCodes.Ldstr, string.Concat(new object[] { objectPrefix, '[', procInfo.SchemaName, "].[", procInfo.SqlName, ']' })); iLGenerator.Emit(OpCodes.Ldc_I4, procInfo.Parameters.Count); iLGenerator.Emit(OpCodes.Newarr, typeof(object)); iLGenerator.Emit(OpCodes.Stloc, local); arg = 0; foreach (Parameter parameter in procInfo.Parameters) { iLGenerator.Emit(OpCodes.Ldloc, local); iLGenerator.Emit(OpCodes.Ldc_I4, arg); iLGenerator.Emit(OpCodes.Ldarg, (int) (arg + 1)); Type clrType = parameter.ClrType; if (useOptional) { clrType = typeof(Optional<>).MakeGenericType(new Type[] { clrType }); } if (clrType.IsValueType) { iLGenerator.Emit(OpCodes.Box, clrType); } iLGenerator.Emit(OpCodes.Stelem_Ref); arg++; } iLGenerator.Emit(OpCodes.Ldloc, local); MethodInfo meth = typeof(DataContextBase).GetMethod("ExecuteStoredProcedure", BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance, null, new Type[] { typeof(string), typeof(object[]) }, null); iLGenerator.Emit(OpCodes.Call, meth); iLGenerator.Emit(OpCodes.Ret); }
private List<ExplorerItem> GetChildItems(SchemaObject o, bool isSqlServer) { IEnumerable<ExplorerItem> first = Enumerable.Empty<ExplorerItem>(); if (o.Parameters.Count > 0) { first = first.Concat<ExplorerItem>(this.GetParams(o)); } first = first.Concat<ExplorerItem>(from col in o.ColumnsInOrder let text = col.PropertyName + " (" + col.ClrType.FormatTypeName() + ")" let sqlTypeDec = col.GetFullSqlTypeDeclaration() select new ExplorerItem(text, ExplorerItemKind.Property, col.IsKey ? ExplorerIcon.Key : ExplorerIcon.Column) { DragText = col.PropertyName, ToolTipText = (sqlTypeDec == null) ? null : (col.ColumnName + " " + sqlTypeDec), SqlName = col.ColumnName, SqlTypeDeclaration = sqlTypeDec }); Table t = o as Table; if (t != null) { IOrderedEnumerable<ExplorerItem> second = from a in this.GetParents(t).Concat<ExplorerItem>(this.GetChildren(t)) orderby a.Icon != ExplorerIcon.OneToOne select a; first = first.Concat<ExplorerItem>(second); if (!(t.HasKey || !isSqlServer)) { first = first.Concat<ExplorerItem>(new ExplorerItem[] { new ExplorerItem("(Warning: No primary key, updates will fail)", ExplorerItemKind.Property, ExplorerIcon.Inherited) }); } } return first.ToList<ExplorerItem>(); }
private IEnumerable<ExplorerItem> GetParams(SchemaObject o) { return (from p in o.Parameters select new ExplorerItem(p.ClrName + " (" + p.ClrType.FormatTypeName() + ")", ExplorerItemKind.Parameter, ExplorerIcon.Parameter) { DragText = p.ClrName, SqlName = p.ParamName }); }
public FunctionGenerator(EmissionsGenerator egen, TypeBuilder dcType, SchemaObject funcInfo, string methodName, MethodAttributes accessibility) { Type resultType; this.EGen = egen; this.DCType = dcType; this.FunctionInfo = funcInfo; if (funcInfo is TableFunction) { this.ResultType = egen._tableTypes[funcInfo.DotNetName]; } else { if (funcInfo.ReturnInfo == null) { return; } this.ResultType = funcInfo.ReturnInfo.ClrType; } if (funcInfo is TableFunction) { resultType = typeof(IQueryable<>).MakeGenericType(new Type[] { this.ResultType }); } else { resultType = this.ResultType; } this.Method = dcType.DefineMethod(methodName, accessibility, resultType, (from p in funcInfo.Parameters select p.ClrType).ToArray<Type>()); }