예제 #1
0
        private static void ReadSource(string sourceFile,
                                       Options options,
                                       List <DbProcDeclaration> procs,
                                       List <DbRowsetDeclaration> rowsets,
                                       List <DbTableTypeDeclaration> tableTypes)
        {
            var parser = new DbProcParser();
            var decls  = parser.Parse(File.ReadAllText(sourceFile));

            decls.ForEach(d =>
            {
                d.Params.ForEach(p => p.Nullable = options.Nullable);
            });

            procs.AddRange(decls);
        }
예제 #2
0
        private static void ReadOption(string optionFile,
                                       Options options,
                                       List <DbProcDeclaration> procs,
                                       List <DbRowsetDeclaration> rowsets,
                                       List <DbTableTypeDeclaration> tableTypes)
        {
            var joption = JsonConvert.DeserializeObject <JsonOption>(File.ReadAllText(optionFile));
            var baseDir = Path.GetDirectoryName(optionFile);

            if (joption.Procs != null)
            {
                var parser = new DbProcParser();
                foreach (var jproc in joption.Procs)
                {
                    List <DbProcDeclaration> decls;

                    if (string.IsNullOrEmpty(jproc.Path) == false)
                    {
                        decls = parser.Parse(File.ReadAllText(Path.Combine(baseDir, jproc.Path)));
                    }
                    else if (string.IsNullOrEmpty(jproc.Source) == false)
                    {
                        decls = parser.Parse(jproc.Source);
                    }
                    else
                    {
                        throw new ArgumentException("Path or Source is required: " + jproc);
                    }

                    decls.ForEach(d =>
                    {
                        d.ClassName   = jproc.ClassName;
                        d.Return      = jproc.Return;
                        d.Rowset      = jproc.Rowset;
                        d.RowsetFetch = jproc.RowsetFetch;
                        d.Params.ForEach(p => p.Nullable = jproc.Nullable ?? options.Nullable);
                    });
                    procs.AddRange(decls);
                }
            }

            if (joption.Rowsets != null)
            {
                foreach (var jrowset in joption.Rowsets)
                {
                    var rowset = new DbRowsetDeclaration();
                    rowset.ClassName = jrowset.Name;
                    rowset.Fields    = jrowset.Fields.Select(s =>
                    {
                        var strs = s.Split();
                        if (strs[0].EndsWith("?"))
                        {
                            return(new DbField
                            {
                                Type = strs[0].Substring(0, strs[0].Length - 1),
                                Name = strs[1],
                                Nullable = true
                            });
                        }
                        else
                        {
                            return(new DbField
                            {
                                Type = strs[0],
                                Name = strs[1]
                            });
                        }
                    }).ToList();
                    rowsets.Add(rowset);
                }
            }

            if (joption.TableTypes != null)
            {
                var parser = new DbTableTypeParser();
                foreach (var jtype in joption.TableTypes)
                {
                    List <DbTableTypeDeclaration> decls;

                    if (string.IsNullOrEmpty(jtype.Path) == false)
                    {
                        decls = parser.Parse(File.ReadAllText(Path.Combine(baseDir, jtype.Path)));
                    }
                    else if (string.IsNullOrEmpty(jtype.Source) == false)
                    {
                        decls = parser.Parse(jtype.Source);
                    }
                    else
                    {
                        throw new ArgumentException("Path or Source is required: " + jtype);
                    }

                    decls.ForEach(d =>
                    {
                        d.ClassName = jtype.ClassName;
                    });
                    tableTypes.AddRange(decls);
                }
            }
        }