コード例 #1
0
ファイル: Start.cs プロジェクト: jcde/CommandUtils
        private static void Generate(DAType dt)
        {
            if (OptionValue("pressKey") != null)
            {
                Console.Read();
            }

            string assembliesDir = OptionValue("dll");
            if (!Directory.Exists(assembliesDir))
            {
                Console.WriteLine("Source directory does not exist. Current dir used.");
            }
            else
            {
                AssemblyTypesCollection.DefaultAssemblyScanStrategy =
                    new AppDomainBaseDirectoryStrategy(assembliesDir);
            }

            string targetDir;
            if (OptionValue("t") != null)
            {
                targetDir = OptionValue("t");
            }
            else
                targetDir = AppDomain.CurrentDomain.BaseDirectory;
            targetDir = Path.Combine(targetDir, dt.ToString());
            if (!string.IsNullOrEmpty(targetDir) && !Directory.Exists(targetDir))
                Directory.CreateDirectory(targetDir);

            var targetFileName = Path.Combine(targetDir,
                                              ((OptionValue("noTables") == null) ? "CreateDBScript.sql" : "DefaultInserts.sql"));

            Console.WriteLine("The result will be at {0}.", targetFileName);

            if (File.Exists(targetFileName))
            {
                Console.WriteLine("Target file name will be overwritten");
            }

            CultureInfo cUI = Thread.CurrentThread.CurrentUICulture;
            CultureInfo myCIclone = (CultureInfo)cUI.Clone();
            myCIclone.NumberFormat.NumberGroupSeparator = "";
            myCIclone.NumberFormat.NumberDecimalSeparator = ".";
            myCIclone.NumberFormat.CurrencyDecimalSeparator = ".";
            Thread.CurrentThread.CurrentUICulture = myCIclone;
            Thread.CurrentThread.CurrentCulture = myCIclone;

            using (StreamWriter Target = File.CreateText(targetFileName))
            {
                IList scripted = new ArrayList();
                IList notScripted = new ArrayList();
                IList scriptedTables = new ArrayList();
                DescriptorCache.Instance = null;
                foreach (TypeDescriptor td in DescriptorCache.Instance)
                {
                    if (CanBeScripted(td.RealType, dt))
                    {
                        notScripted.Add(td);
                    }
                }

                int i = 0;
                while (notScripted.Count > 0)
                {
                    //if (i >= notScripted.Count)
                    //	i = notScripted.Count-1;
                    TypeDescriptor td = (TypeDescriptor)notScripted[i];
                    bool notScriptedReference = false;
                    foreach (ReferenceFieldDescriptor rfd in td.ReferenceFields)
                    {
                        if (!rfd.NoForeignKey)
                        {
                            TypeDescriptor refTd = DescriptorCache.Instance[rfd.ReferencedType];
                            if (refTd != td // дозволяється посилатися на самого себе
                                && (CanBeScripted(refTd.RealType, dt))
                                && !scripted.Contains(refTd))
                            {
                                notScriptedReference = true;
                                i++;
                                if (i >= notScripted.Count)
                                {
                                    Console.WriteLine("Circular references in foreign keys found in {0}", td.RealType.FullName);
                                    Console.WriteLine(" to {0}", refTd.RealType.FullName);
                                }
                                break;
                            }
                        }
                    }
                    if (!notScriptedReference)
                    {
                        i = 0;
                        notScripted.Remove(td);
                        scripted.Add(td);
                    }
                }

                if (OptionValue("noTables") == null)
                {
                    for (int j = scripted.Count - 1; j >= 0; j--)
                    {
                        TypeDescriptor td;
                        IList tables2Delete = new ArrayList();
                        for (int ii = j - 1; ii >= 0; ii--)
                        {
                            td = (TypeDescriptor)scripted[ii];
                            foreach (string tableName in td.TableNames.Keys)
                            {
                                if (!tables2Delete.Contains(tableName))
                                    tables2Delete.Add(tableName);
                            }
                        }

                        td = (TypeDescriptor)scripted[j];
                        var tables = new List<string>();
                        foreach (string tableName in td.TableNames.Keys)
                        {
                            if (!tables2Delete.Contains(tableName))
                            {
                                tables.Add(tableName);
                            }
                        }

                        Target.WriteLine(new DeleteEntityCommand(dt).BuildSql(td, tables)[0]);
                    }

                    foreach (TypeDescriptor td in scripted)
                    {
                        var tables = new List<string>();
                        foreach (string tableName in td.TableNames.Keys)
                        {
                            if (!scriptedTables.Contains(tableName))
                            {
                                tables.Add(tableName);
                                scriptedTables.Add(tableName);
                            }
                        }

                        Console.WriteLine("Parsing class {0}...", td.RealType.FullName);
                        Target.WriteLine(new CreateEntityCommand(dt).BuildSql(td, tables)[0]);
                    }
                }

                if (OptionValue("sp") != null)
                {
                    Console.WriteLine("Generation standard stored procedures...");
                    foreach (TypeDescriptor td in scripted)
                    {
                        Target.WriteLine(new CreateStandardProceduresCommand(dt).BuildSql(td)[0]);
                    }
                }

                if (OptionValue("r") != null)
                {
                    Console.WriteLine("Generation reference data...");
                    foreach (TypeDescriptor td in scripted)
                    {
                        try
                        {
                            Target.WriteLine();
                            Target.WriteLine("-- Table " + td.Name);
                            IPersistent obj = (IPersistent)Activator.CreateInstance(td.RealType);
                            foreach (IPersistent o in obj.DefaultValues())
                            {
                                var command = new InsertCommand(dt);
                                string sql = command.BuildSql(td, SqlGenerator.GetObjectParameters(o), false)[0];
                                if (dt == DAType.Oracle)
                                    sql += "\r\n;\r\n";
                                Target.WriteLine(sql);
                            }
                        }
                        catch (Exception ex)
                        {
                            Console.WriteLine(string.Format("Error for class {0}: {1}", td.Name, ex.Message));
                        }
                    }
                }
                Target.Flush();
                Console.WriteLine("Creation scripts successfully created.");
            }
        }