internal static string MakeSelectItemTemplate(ITableSchema schema)
        {
            StringBuilder sb = new StringBuilder(100);

            sb.Append("SELECT TOP 1 ");
            int nx = 0;

            foreach (ColumnAttribute col in schema.Cols.Values)
            {
                if (nx++ > 0)
                {
                    sb.Append(",");
                }
                sb.Append(col.Name);
            }
            sb.AppendFormat(" FROM {0}", schema.TableName);
            sb.Append(" WITH (NOLOCK) WHERE ");
            nx = 0;
            foreach (ColumnAttribute key in schema.Keys.Values)
            {
                if (nx++ > 0)
                {
                    sb.Append(" AND ");
                }
                sb.Append(string.Format("{0}=@{0}", key.Name));
            }
            sb.Append(";");
            return(sb.ToString());
        }
Beispiel #2
0
        private void ValidateColumns(EntityMapping mapping, ITableSchema tb, StringBuilder errors)
        {
            var scriptGenerator = this.Option.ScriptGenerator();

            foreach (var m in mapping.innerMappingMembers.Where(p => p.isColumn))
            {
                var c = tb.AllColumns.FirstOrDefault(p => p.ColumnName.ToLower() == m.columnName.ToLower());
                if (c == null)
                {
                    errors.AppendFormat("Missing column: {0} in {1}", m.columnName, tb.TableName).AppendLine();
                    continue;
                }

                var memberType = m.memberType.IsNullable() ? Nullable.GetUnderlyingType(m.memberType) : m.memberType;
                if (c.Type == memberType)
                {
                    continue;
                }

                var currentDbType = scriptGenerator.GetDbType(m.sqlType).ToLower();
                if (!currentDbType.StartsWith(c.ColumnType.ToLower()))
                {
                    errors.AppendFormat("Wrong column type in {0} for column {1}. Found: {2}, Expected {3}", tb.TableName,
                                        c.ColumnName,
                                        currentDbType,
                                        c.ColumnType)
                    .AppendLine();
                }
            }
        }
        public static string GetEnumNameColumnName(ITableSchema table)
        {
            string result = String.Empty;

            foreach (ColumnSchema column in table.Columns)
            {
                if (Configuration.Instance.EnumRegexIsMatch(column.Name, true))
                {
                    result = column.Name;
                    break;
                }
            }

            // If no Regex match found, use first column of type String.
            if (String.IsNullOrEmpty(result))
            {
                foreach (ColumnSchema column in table.Columns)
                {
                    if (column.SystemType == typeof(string))
                    {
                        result = column.Name;
                        break;
                    }
                }
            }

            return(result);
        }
Beispiel #4
0
        public IEntityModel Convert(ITableSchema table)
        {
            var entity = new EntityModel {
                Table = table
            };

            entity.ClassName = NamingConversion.ClassName(table.TableName);
            foreach (var col in table.AllColumns)
            {
                var member = new MemberModel {
                    Column = col, MemberName = PopulateMemberName(entity, NamingConversion.PropertyName(col.ColumnName))
                };
                entity.members.Add(member);
            }

            foreach (var col in table.ForeignKeys)
            {
                var member = new NavigationMemberModel {
                    IsManyToOne = true, Relation = col, MemberName = PopulateMemberName(entity, NamingConversion.ManyToOneName(col))
                };
                member.DeclareTypeName = NamingConversion.ClassName(col.OtherTable.TableName);
                entity.manyToOnes.Add(member);
            }

            foreach (var col in table.Children)
            {
                var member = new NavigationMemberModel {
                    Relation = col, MemberName = PopulateMemberName(entity, NamingConversion.QueryableName(col.OtherTable.TableName))
                };
                member.DeclareTypeName = NamingConversion.ClassName(col.OtherTable.TableName);
                entity.manyToOnes.Add(member);
            }
            return(entity);
        }
Beispiel #5
0
        private IEnumerable <IColumn> GetColumns(ITableSchema tableSchema)
        {
            var list = new List <IColumn>();

            foreach (var columnSchema in tableSchema.Columns)
            {
                var column     = new Column(columnSchema);
                var columnType = this.GetColumnType(columnSchema);

                if (columnType != null)
                {
                    column.PropertyType = columnType.Type.FullName;

                    var primaryKey = tableSchema.PrimaryKeys.FirstOrDefault(x => x.ColumnName.Equals(columnSchema.ColumnName, StringComparison.InvariantCultureIgnoreCase));

                    if (primaryKey != null)
                    {
                        column.PrimaryKey = true;
                        column.Generated  = primaryKey.AutoIncrement;
                    }

                    column.DbType = this._dbTypeService.GetDbType(columnSchema, columnType, primaryKey);
                }

                list.Add(column);
            }

            return(list);
        }
        private static ITableSchema GetToManyTable(ITableSchema manyToTable, ITableSchema sourceTable)
        {
            if (manyToTable == null || sourceTable == null)
            {
                return(null);
            }

            // This will return null if the one or two of the foreign keys point to the manyToMany Table.
            if (!manyToTable.IsManyToMany() && manyToTable.ForeignKeys.Count(m => m.PrimaryKeyTable.FullName.Equals(sourceTable.FullName, StringComparison.InvariantCulture)) > 0)
            {
                return(null);
            }

            ITableSchema result = null;

            foreach (TableKeySchema key in manyToTable.ForeignKeys)
            {
                if (!key.PrimaryKeyTable.FullName.Equals(sourceTable.FullName, StringComparison.InvariantCulture))
                {
                    result = key.PrimaryKeyTable;
                    break;
                }
            }

            return(result);
        }
        public IEntityModel Convert(ITableSchema table)
        {
            var entity = new EntityModel { Table = table };
            entity.ClassName = NamingConversion.ClassName(table.TableName);
            foreach (var col in table.AllColumns)
            {
                var member = new MemberModel { Column = col, MemberName = PopulateMemberName(entity, NamingConversion.PropertyName(col.ColumnName)) };
                entity.members.Add(member);
            }

            foreach (var col in table.ForeignKeys)
            {
                var member = new NavigationMemberModel { IsManyToOne = true, Relation = col, MemberName = PopulateMemberName(entity, NamingConversion.ManyToOneName(col)) };
                member.DeclareTypeName = NamingConversion.ClassName(col.OtherTable.TableName);
                entity.manyToOnes.Add(member);
            }

            foreach (var col in table.Children)
            {
                var member = new NavigationMemberModel { Relation = col, MemberName = PopulateMemberName(entity, NamingConversion.QueryableName(col.OtherTable.TableName)) };
                member.DeclareTypeName = NamingConversion.ClassName(col.OtherTable.TableName);
                entity.manyToOnes.Add(member);
            }
            return entity;
        }
        public static SqlCommand GetSelectItemCommand <T>()
            where T : BusinessBase <T>
        {
            ITableSchema schema      = BusinessBase <T> .Schema;
            string       commandtext = String.Format(MakeSelectItemTemplate(schema));
            SqlCommand   cmd         = null;
            SqlCommand   tmpCmd      = null;

            try
            {
                tmpCmd             = new SqlCommand();
                tmpCmd.CommandText = commandtext;
                tmpCmd.CommandType = CommandType.Text;
                cmd    = tmpCmd;
                tmpCmd = null;
            }
            finally
            {
                if (tmpCmd != null)
                {
                    tmpCmd.Dispose(); tmpCmd = null;
                }
            }
            return(cmd);
        }
Beispiel #9
0
        public static string GenerateTemplate(ITableSchema schema, SqlScriptType type, bool ifExists)
        {
            TableName   tableName = schema.TableName;
            TableClause script    = new TableClause(schema);

            switch (type)
            {
            case SqlScriptType.INSERT:
                return(script.INSERT(schema.Columns));

            case SqlScriptType.SELECT:
                return(script.SELECT(schema.Columns));

            case SqlScriptType.UPDATE:
                return(script.UPDATE(schema.Columns));

            case SqlScriptType.INSERT_OR_UPDATE:
                return(script.INSERT_OR_UPDATE(schema.Columns));

            case SqlScriptType.DELETE:
                return(new Dependency(tableName.DatabaseName).DELETE(tableName)
                       + script.DELETE(schema.Columns));

            case SqlScriptType.DROP:
                return(new Dependency(tableName.DatabaseName).DROP_TABLE(tableName, ifExists)
                       + script.DROP_TABLE(ifExists));
            }

            return(null);
        }
Beispiel #10
0
        public static SqlCommand GetSelectItemCommand <T>(string template, T instance)
            where T : BusinessBase <T>
        {
            ITableSchema schema = BusinessBase <T> .Schema;
            SqlCommand   cmd    = null;
            SqlCommand   tmpCmd = null;

            try
            {
                tmpCmd             = new SqlCommand();
                tmpCmd.CommandType = CommandType.Text;

                StringBuilder sb = new StringBuilder();
                int           nx = 0;
                foreach (ColumnAttribute key in schema.Keys.Values)
                {
                    System.Reflection.FieldInfo field = typeof(T).GetField(key.Storage, BindingFlags.NonPublic | BindingFlags.Instance);
                    tmpCmd.Parameters.AddWithValue("@" + key.Name, field.GetValue(instance));
                    sb.Append(string.Format("{0}{1}=@{1}", nx == 0 ? "" : " and ", key.Name));
                    nx++;
                }
                tmpCmd.CommandText = String.Format(template, " TOP 1", (sb.Length == 0 ? "" : " WHERE " + sb.ToString()), "");
                cmd    = tmpCmd;
                tmpCmd = null;
            }
            finally
            {
                if (tmpCmd != null)
                {
                    tmpCmd.Dispose(); tmpCmd = null;
                }
            }
            return(cmd);
        }
Beispiel #11
0
        public static SqlCommand GetSelectItemCommand <T>(T instance)
            where T : BusinessBase <T>
        {
            ITableSchema schema      = BusinessBase <T> .Schema;
            string       commandtext = String.Format(MakeSelectItemTemplate(schema));
            SqlCommand   cmd         = null;
            SqlCommand   tmpCmd      = null;

            try
            {
                tmpCmd             = new SqlCommand();
                tmpCmd.CommandText = commandtext;
                tmpCmd.CommandType = CommandType.Text;

                // Fill in parameter values
                foreach (ColumnAttribute key in schema.Keys.Values)
                {
                    System.Reflection.FieldInfo field = typeof(T).GetField(key.Storage, BindingFlags.NonPublic | BindingFlags.Instance);
                    tmpCmd.Parameters.AddWithValue("@" + key.Name, field.GetValue(instance));
                }

                cmd    = tmpCmd;
                tmpCmd = null;
            }
            finally
            {
                if (tmpCmd != null)
                {
                    tmpCmd.Dispose(); tmpCmd = null;
                }
            }
            return(cmd);
        }
Beispiel #12
0
        public static SqlCommand GetSelectCommand <T>(SqlFilter filter)
            where T : BusinessBase <T>
        {
            ITableSchema schema      = BusinessBase <T> .Schema;
            string       commandtext = String.Format(MakeSelectTemplate(schema),
                                                     filter.TopN > 0 ? " TOP " + filter.TopN : "",
                                                     filter.Where.Length > 0 ? " WHERE " + filter.Where : "",
                                                     filter.OrderBy.Length > 0 ? " ORDER BY " + filter.OrderBy : "");
            SqlCommand cmd    = null;
            SqlCommand tmpCmd = null;

            try
            {
                tmpCmd             = new SqlCommand();
                tmpCmd.CommandText = commandtext;
                tmpCmd.CommandType = CommandType.Text;
                cmd    = tmpCmd;
                tmpCmd = null;
            }
            finally
            {
                if (tmpCmd != null)
                {
                    tmpCmd.Dispose(); tmpCmd = null;
                }
            }
            return(cmd);
        }
Beispiel #13
0
        public DpoClass(ITableSchema metaTable, ClassName cname, DpoOption option)
        {
            this.metaTable = metaTable;

            this.nameSpace = cname.Namespace;
            this.className = cname.Class;

            this.option = option;

            this.code = new CSharpBuilder {
                Namespace = cname.Namespace,
            };

            code.AddUsing("System");
            code.AddUsing("System.Collections.Generic");
            code.AddUsing("System.Text");
            code.AddUsing("System.Data");
            code.AddUsing("System.Drawing");
            code.AddUsing("Sys.Data");
            code.AddUsing("Sys.Data.Manager");

            clss = new Class(cname.Class, new CodeBuilder.TypeInfo {
                Type = typeof(DPObject)
            })
            {
                Modifier = Modifier.Public | Modifier.Partial,
                Sorted   = option.CodeSorted
            };

            this.code.AddClass(clss);

            nonvalized     = NonvalizedList(nameSpace, className);
            nullableFields = NullableList(nameSpace, className);
        }
Beispiel #14
0
        internal static string MakeSelectKeyTemplate(ITableSchema schema, string selectTemplate)
        {
            if (!selectTemplate.StartsWith("SELECT{0}"))
            {
                throw new Exception("Invalid select template for key query");
            }
            int np = selectTemplate.IndexOf(" FROM ");

            if (np < 0)
            {
                throw new Exception("Invalid select template for key query");
            }

            StringBuilder sb = new StringBuilder(100);

            sb.Append("SELECT{0} ");
            int nx = 0;

            foreach (ColumnAttribute col in schema.Keys.Values)
            {
                if (nx++ > 0)
                {
                    sb.Append(",");
                }
                sb.Append(col.Name);
            }
            // Now append everything from the select template starting from the " FROM " marker...
            sb.Append(selectTemplate.Substring(np));
            return(sb.ToString());
        }
        /// <summary>
        /// </summary>
        /// <param name="source"></param>
        /// <param name="tableKeySchema"></param>
        /// <returns></returns>
        public static TableAssociation FromChildPrimaryKey(TableEntity source, ITableKeySchema tableKeySchema)
        {
            //In Child Associations, the ForeignKey should be the associated entity
            IEntity associationEntity = EntityStore.Instance.GetEntity(tableKeySchema.ForeignKeyTable.FullName);

            if (associationEntity == null && !Configuration.Instance.IncludeManyToManyEntity && tableKeySchema.ForeignKeyTable.IsManyToMany())
            {
                associationEntity = EntityStore.Instance.GetExcludedEntity(tableKeySchema.ForeignKeyTable.FullName);
            }

            if (associationEntity == null)
            {
                return(null);
            }

            TableAssociation association = null;

            foreach (IMemberColumnSchema foreignColumn in tableKeySchema.ForeignKeyMemberColumns)
            {
                //Added a check to see if the FK is also a Foreign composite key (http://community.codesmithtools.com/forums/t/10266.aspx).
                bool isForeignKeyAlsoComposite = foreignColumn.Table.HasPrimaryKey && foreignColumn.Table.PrimaryKey.MemberColumns.Count > 1 && foreignColumn.IsPrimaryKeyMember && foreignColumn.IsForeignKeyMember;

                if (!foreignColumn.IsPrimaryKeyMember || isForeignKeyAlsoComposite)
                {
                    if (foreignColumn.Table.IsManyToMany())
                    {
                        //&& foreignTable != null) // NOTE: This can because a ManyToMany can be to itself.
                        ITableSchema foreignTable = GetToManyTable(foreignColumn.Table, source.EntitySource) ?? source.EntitySource;
                        association = FromChildManyToMany(source, foreignColumn, foreignTable.FullName);
                    }
                    else
                    {
                        var type = AssociationType.OneToMany;
                        if (tableKeySchema.ForeignKeyMemberColumns.Count(m => m.AllowDBNull) == tableKeySchema.ForeignKeyMemberColumns.Count)
                        {
                            type = AssociationType.ZeroOrOneToMany;
                        }
                        else if (!isForeignKeyAlsoComposite && tableKeySchema.ForeignKeyMemberColumns.Count(m => m.IsUnique || m.IsPrimaryKeyMember) == tableKeySchema.ForeignKeyMemberColumns.Count)
                        {
                            type = AssociationType.OneToZeroOrOne;
                        }

                        association = new TableAssociation(tableKeySchema, type, source, associationEntity, true);
                    }
                }
                else if (GetToManyTable(foreignColumn.Table, source.EntitySource) == null)
                {
                    association = new TableAssociation(tableKeySchema, AssociationType.OneToZeroOrOne, source, associationEntity, true);
                }
            }

            //End Association between AspNetUser -> ASpNetRole with Intermediary table as a property
            if (association == null || association.Properties.Count <= 0 || String.IsNullOrEmpty(association.AssociationKey))
            {
                return(null);
            }

            return(association);
        }
        /// <summary>
        /// Checks to see if a Table is part of a ManyToMany relationship. It checks for the following:
        /// 1) Table must have Two ForeignKeys.
        /// 2) All columns must be either...
        /// a) IProperty of the Primary Key.
        /// b) IProperty of a Foreign Key.
        /// c) A DateTime stamp (CreateDate, EditDate, etc).
        /// d) Name matches Version Regex.
        /// </summary>
        /// <param name="table"></param>
        /// <returns></returns>
        public static bool IsManyToMany(this ITableSchema table)
        {
            if (!Configuration.Instance.IncludeManyToManyAssociations)
            {
                return(false);
            }

            // Bypass logic if table contains Extended Property for ManyToMany
            if (table.ExtendedPropertiesContainsKey(Configuration.Instance.ManyToManyExtendedProperty))
            {
                bool manyToMany;
                if (Boolean.TryParse(table.ExtendedProperties[Configuration.Instance.ManyToManyExtendedProperty].Value.ToString(), out manyToMany))
                {
                    if (!manyToMany)
                    {
                        return(false);
                    }

                    // Table must have atleast two fk's...
                    if (table.ForeignKeys.Count < 2)
                    {
                        return(false);
                    }

                    return(true);
                }
            }

            // 1) Table must have Two ForeignKeys.
            // 2) All columns must be either...
            //    a) IProperty of the Primary Key.
            //    b) IProperty of a Foreign Key.
            //    c) A DateTime stamp (CreateDate, EditDate, etc).
            //    d) Name matches Version Regex.

            // has to be at least 2 columns
            if (table.Columns.Count < 2)
            {
                return(false);
            }

            if (table.ForeignKeys.Count != 2)
            {
                return(false);
            }

            foreach (IColumnSchema column in table.Columns)
            {
                //bool isManyToMany = (column.IsForeignKeyMember || column.IsPrimaryKeyMember || column.SystemType.Equals(typeof(DateTime)) || (Configuration.Instance.UseRowVersionRegex && Configuration.Instance.RowVersionColumnRegex.IsMatch(column.Name)));
                // Had to apply this stupid workaround because Microsoft IEntity Framework doesn't support IdentityColumns as Part of a Many-To-Many.
                bool isManyToMany = (column.IsForeignKeyMember || (column.IsColumnComputed() && !column.IsColumnIdentity()) || (Configuration.Instance.UseRowVersionRegex && Configuration.Instance.RowVersionColumnRegex.IsMatch(column.Name))) && !column.AllowDBNull;
                if (!isManyToMany)
                {
                    return(false);
                }
            }

            return(true);
        }
Beispiel #17
0
        public BrokerOfDataContract1()
        {
            this.type      = typeof(TEntity);
            this.extension = HostType.GetType(type.FullName + EXTENSION);

            this.Schema = extension.GetTableSchemaFromType();
            this.functionToDictionary = extension.GetMethod(nameof(ToDictionary), BindingFlags.Public | BindingFlags.Static);
        }
 /// <summary>
 /// </summary>
 /// <param name="table"></param>
 /// <returns></returns>
 public static bool IsEnum(this ITableSchema table)
 {
     return(Configuration.Instance.EnumRegexIsMatch(table.FullName, false) && // 1) Matches the Enum Regex.
            table.HasPrimaryKey && // 2) Has a Primary Key...
            table.PrimaryKey.MemberColumns.Count == 1 && // 3) ...that is a single column...
            IsEnumSystemType(table.PrimaryKey.MemberColumns[0]) && // 4) ...of a number type.
            !String.IsNullOrEmpty(GetEnumNameColumnName(table)));   // 5) Contains a column for name.
 }
Beispiel #19
0
        public TableCompare(ITableSchema schema1, ITableSchema schema2)
        {
            this.SideType      = CompareSideType.compare;
            this.ExceptColumns = new string[] { };

            this.schema1 = schema1;
            this.schema2 = schema2;
        }
Beispiel #20
0
        public TableDataClause(ITableSchema schema)
        {
            this.schema    = schema;
            this.tableName = schema.TableName;
            this.template  = new SqlTemplate(tableName);

            this.pk = schema.PrimaryKeys.Keys;
            this.ik = schema.Identity.ColumnNames;
            this.ck = schema.Columns.Where(column => column.IsComputed).Select(column => column.ColumnName).ToArray();
        }
Beispiel #21
0
        public static int GenerateRows(SqlScriptType type, StreamWriter writer, ITableSchema schema, Locator where, SqlScriptGenerationOption option, IProgress <int> progress)
        {
            SqlScriptGeneration gen = new SqlScriptGeneration(type, schema)
            {
                Where  = where,
                Option = option,
            };

            return(gen.Generate(writer, progress));
        }
Beispiel #22
0
 public static string FormalTableName(this ITableSchema schema)
 {
     if (schema.SchemaName == SchemaName.dbo || schema.SchemaName == SchemaName.empty)
     {
         return(string.Format("[{0}]", schema.TableName));
     }
     else
     {
         return($"[{schema.SchemaName}].[{schema.TableName}]");
     }
 }
Beispiel #23
0
        private IEnumerable <IAssociation> GetAssociations(ITableSchema tableSchema)
        {
            var list = new List <IAssociation>();

            foreach (var associationSchema in tableSchema.Associations)
            {
                list.Add(new Association(associationSchema));
            }

            return(list);
        }
Beispiel #24
0
        public Table(ITableSchema schema, IPluralizationService pluralizationService)
        {
            ArgumentUtility.CheckNotNull("schema", schema);
            ArgumentUtility.CheckNotNullOrEmpty("schema.TableName", schema.TableName);
            ArgumentUtility.CheckNotNull("pluralizationService", pluralizationService);

            this.TableName  = schema.TableName;
            this.EntityName = pluralizationService.Singularize(schema.TableName)
                              .ToSafeClrName(schema.TableName.ShouldForceProperCase());
            this.IsView = schema.IsView;
        }
Beispiel #25
0
        /// <summary>
        /// use default locator to save records into database, primary keys must be defined
        /// </summary>
        /// <param name="tableName"></param>
        public TableWriter(TableName tableName)
        {
            this.schema = tableName.GetTableSchema();

            IPrimaryKeys primary = schema.PrimaryKeys;

            if (primary.Length != 0)
            {
                this.locator = new Locator(primary);
            }
        }
Beispiel #26
0
 /// <summary>
 /// 初始化
 /// </summary>
 /// <param name="databaseSchema">获取数据库结构信息接口</param>
 /// <param name="tableSchema">表架构接口</param>
 public BuildDatabase(IDatabaseSchema databaseSchema, ITableSchema tableSchema)
 {
     if (databaseSchema == null)
     {
         throw new ArgumentNullException("databaseSchema");
     }
     if (tableSchema == null)
     {
         throw new ArgumentNullException("tableSchema");
     }
     this.databaseSchema = databaseSchema;
     this.tableSchema    = tableSchema;
 }
Beispiel #27
0
        internal static string GenerateCREATE_TABLE(ITableSchema table)
        {
            string fields = string.Join(Environment.NewLine, table.Columns.Select(column => "\t" + column.GetSQLField() + ","));

            if (table.TableName.Provider.DpType == DbProviderType.Sqlite)
            {
                return(CREATE_TABLE(fields, table.PrimaryKeys, table.ForeignKeys));
            }
            else
            {
                return(CREATE_TABLE(fields, table.PrimaryKeys));
            }
        }
Beispiel #28
0
        /// <summary>
        /// 释放资源
        /// </summary>
        public void Dispose()
        {
            if (databaseSchema != null)
            {
                databaseSchema.Dispose();
            }
            if (tableSchema != null)
            {
                tableSchema.Dispose();
            }

            this.databaseSchema = null;
            this.tableSchema    = null;
        }
Beispiel #29
0
        internal Table(DataContext context)
        {
            this.Context = context;
            this.broker  = BrokerOfDataContract <TEntity> .CreateBroker(context.ClassType);

            this.schema     = broker.Schema;
            this.formalName = schema.FormalTableName();

            this.Generator = new SqlMaker(formalName)
            {
                PrimaryKeys  = schema.PrimaryKeys,
                IdentityKeys = schema.IdentityKeys,
            };
        }
        public bool Build(string _codefilesavepath, string guid)
        {
            try
            {
                string templateFileName;//= Path.GetFileName(_template_name);
                string templateDirPath;
                templateFileFullPath = GetTemplateInfo(_template_name, out templateDirPath, out templateFileName);
                List <ITableSchema> allTables    = GetAllTableSchema(_setting, _tables, guid);
                ITableSchema        currentTable = allTables.Find(it => it.Name.Equals(_table_name));
                this.Constant.TemplateName = templateFileName;
                TemplateResolver th   = new TemplateResolver(templateDirPath);
                xUtils           util = new xUtils();
                th.Put("Tables", allTables);
                th.Put("Table", currentTable);
                th.Put("Utils", util);
                th.Put("Const", this.Constant);
                if (ContainRows(templateFileFullPath))
                {
                    var fac = DatabaseResolver.GetDataFactory(this._setting);
                    th.Put("Rows", fac.GetTableData(this._table_name).ToDynamic());
                }
                string text = th.BuildString(templateFileName);

                var    customerDefine = BlockCommentDictionary(text);
                string filename       = util.ToPascalCase(_table_name) + ".generate.cs";
                if (customerDefine.Count > 0 && customerDefine.ContainsKey("filename"))
                {
                    filename = customerDefine["filename"];
                }

                if (!Directory.Exists(_codefilesavepath))
                {
                    Directory.CreateDirectory(_codefilesavepath);
                }
                string fullsavefilename = _codefilesavepath + "/" + filename;
                if (File.Exists(fullsavefilename))
                {
                    File.Delete(fullsavefilename);
                }
                File.AppendAllText(fullsavefilename, text);
                return(true);
            }
            catch (Exception ex)
            {
                this.ExceptionMessage = ex.Message;
                LogText(string.Concat(Environment.NewLine, ex.StackTrace));
                return(false);
            }
        }
Beispiel #31
0
        internal static string MakeSelectKeyTemplate(ITableSchema schema)
        {
            StringBuilder sb = new StringBuilder(100);

            sb.Append("SELECT{0} ");
            int nx = 0;

            foreach (ColumnAttribute col in schema.Keys.Values)
            {
                if (nx++ > 0)
                {
                    sb.Append(",");
                }
                sb.Append(col.Name);
            }
            sb.AppendFormat(" FROM {0}", schema.TableName);
            sb.Append(" WITH (NOLOCK){1}{2}");
            return(sb.ToString());
        }
Beispiel #32
0
 public void Setup()
 {
     Database.SetUp();
     Database.CreateTables();
     GribbleDatabase = Gribble.TableSchema.Create(Database.Connection, profiler: Profiler);
 }