protected override void DoRun(IShellContext context)
        {
            var db = GetDatabaseStructure(context);
            if (Table != null && Tables != null) throw new Exception("DBSH-00085 SetTableProperty: both of Table and tables attribute is set");
            if (Table == null && Tables == null) throw new Exception("DBSH-00086 SetTableProperty: none of Table and tables attribute is set");

            string value = context.Replace(Value);
            if (Table != null)
            {
                var table = db.FindTableLike(Table);
                if (table != null)
                {
                    table.Properties[Name] = value;
                }
            }
            if (Tables != null)
            {
                foreach (var table in db.Tables)
                {
                    if (Regex.Match(table.Name, Tables).Success)
                    {
                        table.Properties[Name] = value;
                    }
                }
            }
        }

 protected override void DoRun(IShellContext context)
 {
     using (var conn = GetConnectionProvider(context).Connect())
     {
         GetModel(context).Prepare(conn);
     }
 }

 ICdlWriter ITabularDataTarget.CreateWriter(TableInfo rowFormat, CopyTableTargetOptions options, IShellContext context, DataFormatSettings sourceDataFormat)
 {
     string file = GetName(context);
     file = context.ResolveFile(file, ResolveFileMode.Output);
     context.OutputMessage("Writing file " + Path.GetFullPath(file));
     return new CdlFileWriter(file, rowFormat);
 }

 ICdlReader ITabularDataSource.CreateReader(IShellContext context)
 {
     TableInfo table;
     BinaryReader br;
     OpenRead(out table, out br, context);
     return new CdlFileReader(table, br);
 }

 protected override void DoRun(IShellContext context)
 {
     var dbs = GetDatabaseStructure(context);
     var model = new DataSetModel(dbs, context, GetConnectionProvider(context).Factory);
     model.KeepUndefinedReferences = KeepUndefinedReferences;
     context.SetVariable(GetDataSetVariableName(context), model);
 }

 protected override void DoRun(IShellContext context)
 {
     context.OutputMessage("Opening MS Excel");
     var model = ExcelModel.CreateNewWindow();
     model.DataFormat = DataFormat;
     context.SetVariable(GetExcelVariableName(context), model);
 }

 protected override void DoRun(IShellContext context)
 {
     string file = context.ResolveFile(context.Replace(File), ResolveFileMode.Input);
     var model = ExcelModel.OpenFile(file);
     model.DataFormat = DataFormat;
     context.SetVariable(GetExcelVariableName(context), model);
 }

 public DataSetModel(DatabaseInfo targetDatabase, IShellContext context, IDatabaseFactory factory)
 {
     _targetDatabase = targetDatabase;
     _context = context;
     _factory = factory;
     _dda = _factory.CreateDataAdapter();
 }

 protected override void DoRun(IShellContext context)
 {
     GetModel(context).LoadReference(
         new NameWithSchema(context.Replace(Schema), context.Replace(Table)),
         context.Replace(Column), 
         new NameWithSchema(context.Replace(RefSchema), context.Replace(RefTable)));
 }

 public ICdlWriter CreateWriter(TableInfo rowFormat, CopyTableTargetOptions options, IShellContext context, DataFormatSettings sourceDataFormat)
 {
     string file = context.ResolveFile(context.Replace(File), ResolveFileMode.Output);
     var fw = new StreamWriter(file);
     var provider = GetConnectionProvider(context);
     return new SqlFileWriter(fw, provider.Factory);
 }

 protected override void DoRun(IShellContext context)
 {
     string file = context.ResolveFile(context.Replace(File), ResolveFileMode.Output);
     if (Expression != null && Value != null) throw new Exception("DBSH-00078 SaveToFile: both Expression and Value is set");
     if (Expression == null && Value == null) throw new Exception("DBSH-00079 SaveToFile: none of Expression and Value is set");
     if (Expression != null)
     {
         object obj = context.Evaluate(Expression);
         if (obj is byte[])
         {
             var bytes = (byte[]) obj;
             using (var fw = System.IO.File.OpenWrite(file))
             {
                 fw.Write(bytes, 0, bytes.Length);
             }
         }
         else
         {
             using (var fw = new StreamWriter(file, false, Encoding))
             {
                 fw.Write(obj.ToString());
             }
         }
     }
     if (Value!=null)
     {
         string val = context.Replace(Value);
         using (var fw = new StreamWriter(file, false, Encoding))
         {
             fw.Write(val);
         }
     }
 }

        //public override void EnumChildren(Action<IShellElement> enumFunc)
        //{
        //    base.EnumChildren(enumFunc);
        //    foreach (var item in Commands) YieldChild(enumFunc, item);
        //}

        protected void RunContainer(IShellContext context)
        {
            foreach(var item in Commands)
            {
                item.Run(context);
            }
        }

 private SocialExplorer.IO.FastDBF.DbfFile OpenDbfRead(IShellContext context)
 {
     var dbf = new SocialExplorer.IO.FastDBF.DbfFile(Encoding);
     var name = context.ResolveFile(context.Replace(Name), ResolveFileMode.Input);
     dbf.Open(name, System.IO.FileMode.Open);
     return dbf;
 }

 protected override void DoRun(IShellContext context)
 {
     string file = context.ResolveFile(context.Replace(File), ResolveFileMode.Output);
     context.OutputMessage("Writing file " + Path.GetFullPath(file));
     var model = ExcelModel.CreateFile(file);
     model.DataFormat = DataFormat;
     context.SetVariable(GetExcelVariableName(context), model);
 }

 public ColumnMapperReader(ICdlReader source, TableInfo outputFormat, List<IColumnMapping> columnMap, List<int> counts, IShellContext context )
     : base(outputFormat)
 {
     _source = source;
     _columnMap = columnMap;
     _counts = counts;
     _context = context;
 }

 private ITabularDataSource CreateSource(IShellContext context)
 {
     string name = GetName(context);
     if (name.ToLower().EndsWith(".cdl")) return new CdlFile {Connection = Connection, Name = name};
     if (name.ToLower().EndsWith(".csv")) return new CsvFile { Connection = Connection, Name = name };
     if (name.ToLower().EndsWith(".xml")) return new XmlReader { Connection = Connection, File = name, AnalyseColumns = true };
     throw new Exception("DBSH-00002 Unknown soruce file type:" + name);
 }

 DataFormatSettings ITabularDataSource.GetSourceFormat(IShellContext context)
 {
     using (var childCtx = context.CreateChildContext())
     {
         childCtx.SetVariable(context.Replace(PropertyName), context.Replace(PrimaryFile));
         return SourceTemplate.GetSourceFormat(childCtx);
     }
 }

 protected override void DoRun(IShellContext context)
 {
     string file = context.ResolveFile(context.Replace(File), ResolveFileMode.Input);
     var model = ShapeFileModel.OpenFile(file, SpatialTool.GetProjection(Projection, context));
     model.DataFormat = DataFormat;
     model.AddFileIdentifier = AddFileIdentifier;
     context.SetVariable(GetShpVariableName(context), model);
 }

        public TargetEntitySqlModel(DataSyncSqlModel dataSyncSqlModel, Target dbsh, IShellContext context)
        {
            this._dataSyncSqlModel = dataSyncSqlModel;
            this._dbsh = dbsh;
            TargetTable = new NameWithSchema(context.Replace(dbsh.TableSchema), context.Replace(dbsh.TableName));
            string findSchema = dbsh.TableSchema;
            if (findSchema != null && findSchema.StartsWith(NameWithSchema.NoQuotePrefix)) findSchema = null;
            Structure = dataSyncSqlModel.TargetStructure.FindTableLike(findSchema, TargetTable.Name);
            SqlAlias = _dbsh.Alias ?? "dst_" + _dataSyncSqlModel.Entities.Count;

            foreach (var col in dbsh.Columns)
            {
                var targetCol = new TargetNoRefColumnSqlModel(col, FindColumnInfo(col.Name));
                TargetColumns.Add(targetCol);

                foreach (string alias in ExtractColumnSources(col))
                {
                    SourceColumnSqlModel source = null;
                    if (dataSyncSqlModel.SourceGraphModel == null)
                    {
                        // flat sync
                        if (!String.IsNullOrEmpty(dbsh.PrimarySource))
                        {
                            var tableSource = DataSync.FlatSources.FirstOrDefault(x => x.Match(Dbsh.PrimarySource));
                            if (tableSource != null)
                            {
                                source = tableSource.Columns.FirstOrDefault(x => x.Alias == alias);
                            }
                        }
                    }
                    else
                    {
                        source = dataSyncSqlModel.SourceGraphModel[alias];
                        //targetCol.Sources.Add(source);
                    }
                    RequiredSourceColumns.Add(source);
                    if (col.IsKey) KeySourceColumns.Add(source);
                }
            }

            if (!String.IsNullOrEmpty(_dbsh.Connection))
            {
                var ctxConn = new NormalizedDatabaseConnectionInfo(new DatabaseConnectionInfoHolder { ProviderString = context.GetDefaultConnection() });
                var tableConn = new NormalizedDatabaseConnectionInfo(new DatabaseConnectionInfoHolder { ProviderString = context.Replace(_dbsh.Connection), LinkedInfo = _dbsh.LinkedInfo });

                if (ctxConn != tableConn)
                {
                    if (ctxConn.ServerConnectionString == tableConn.ServerConnectionString)
                    {
                        TargetLinkedInfo = tableConn.GetLinkedInfo();
                    }
                    else
                    {
                        throw new IncorrectRdsDefinitionException($"DBSH-00000 RDS target must be reachable by database or linked server: ({TargetTable})");
                    }
                }
            }
        }

 protected override void DoRun(IShellContext context)
 {
     string file = context.ResolveFile(context.Replace(File), ResolveFileMode.Output);
     context.OutputMessage("DBSH-00118 Exporting SQL file Writing " + file);
     using (var fw = new StreamWriter(file))
     {
         GetModel(context).WriteSql(fw);
     }
 }