Esempio n. 1
0
        public CSqlOptions CreateCsqlOptions()
        {
            DbConnectionParameter connectionParameter = new DbConnectionParameter();

            connectionParameter.Provider           = this.System;
            connectionParameter.DatasourceAddress  = this.Server;
            connectionParameter.DatasourcePort     = this.ServerPort;
            connectionParameter.Catalog            = this.Database;
            connectionParameter.UserId             = this.User;
            connectionParameter.Password           = this.Password;
            connectionParameter.IntegratedSecurity = string.IsNullOrEmpty(this.User);

            CSqlOptions csqlOptions = new CSqlOptions();

            csqlOptions.ConnectionParameter = connectionParameter;
            csqlOptions.ScriptFile          = this.ScriptFile;
            csqlOptions.TempFile            = this.TempFile;
            csqlOptions.DistributionFile    = this.DistFile;
            csqlOptions.UsePreprocessor     = this.UsePreprocessor;
            csqlOptions.BreakOnError        = this.BreakOnError;
            csqlOptions.NoLogo          = this.NoLogo;
            csqlOptions.Verbosity.Level = (TraceLevel)Verbose;
            csqlOptions.PreprocessorOptions.AdvancedArguments = this.PreprocessorArgs;


            csqlOptions.AddPreprocessorMacros();

            return(csqlOptions);
        }
Esempio n. 2
0
        private void Thread_Start(object obj)
        {
            ThreadParameter         parameter     = (ThreadParameter)obj;
            DTE2                    application   = parameter.Application;
            CSqlOptions             settings      = parameter.CSqlOptions;
            OutputPaneTraceListener traceListener = null;

            try {
                var outputPane = Gui.Output.GetAndActivateOutputPane(application);
                if (outputPane != null)
                {
                    outputPane.Clear();
                    traceListener = new OutputPaneTraceListener(outputPane);
                }

                if (traceListener != null)
                {
                    Trace.Listeners.Add(traceListener);
                }
                this.currentExecutor = new ScriptExecutor(settings);
                this.currentExecutor.Execute();

                if (!String.IsNullOrEmpty(settings.DistributionFile))
                {
                    application.ItemOperations.OpenFile(settings.DistributionFile, Constants.vsViewKindCode);
                }
                currentExecutor = null;
            }
            finally {
                currentExecutor = null;
                if (traceListener != null)
                {
                    Trace.Listeners.Remove(traceListener);
                    traceListener.Close();
                    traceListener.Dispose();
                }
            }
            Commands2 commands = application.Commands as Commands2;

            if (commands != null)
            {
                commands.UpdateCommandUI(false);
            }
        }
Esempio n. 3
0
        private static CSqlOptions CreateCSqlOptions(DbConnectionParameter dbConnectionParameter, ScriptParameter csqlParameter, Document activeDocument)
        {
            CSqlOptions csqlOptions = new CSqlOptions();

            DocumentEnvironment environment = new DocumentEnvironment(activeDocument);
            VariableSubstitutor substitutor = new VariableSubstitutor(environment);

            csqlOptions.ScriptFile = activeDocument.FullName;
            if (csqlParameter.IsOutputFileEnabled)
            {
                string file = substitutor.Substitute(csqlParameter.OutputFile);
                csqlOptions.DistributionFile = file;
            }
            else
            {
                csqlOptions.DistributionFile = null;
            }

            if (csqlParameter.IsTemporaryFileEnabled)
            {
                string file = substitutor.Substitute(csqlParameter.TemporaryFile);
                csqlOptions.TempFile = file;
            }
            else
            {
                csqlOptions.TempFile = null;
            }

            csqlOptions.BreakOnError        = csqlParameter.IsBreakOnErrorEnabled;
            csqlOptions.UsePreprocessor     = csqlParameter.IsPreprocessorEnabled;
            csqlOptions.ConnectionParameter = dbConnectionParameter;
            csqlOptions.PreprocessorOptions = CreatePreprocessorArguments(substitutor, csqlParameter);
            csqlOptions.AddPreprocessorMacros();

            csqlOptions.Verbosity.Level = csqlParameter.Verbosity;

            csqlOptions.NoLogo = false;
            csqlOptions.MaxResultColumnWidth = csqlParameter.MaxResultColumnWidth;

            return(csqlOptions);
        }
Esempio n. 4
0
 public ScriptExecutor(CSqlOptions csqlOptions)
 {
     this.csqlOptions = csqlOptions;
     this.processor   = new Processor(csqlOptions);
 }
Esempio n. 5
0
        public static int Main(string[] args)
        {
            // If run without any argument show dialog with parameter usage.
            // Prefer dialog over command line to make windows client software
            // logo toolkit happy.
            if (args.Length == 0)
            {
                string      usage            = CommandLine.Parser.ArgumentsUsage(typeof(CmdArgs));
                var         usageDialogItems = GetUsageDialogData();
                UsageDialog dialog           = new UsageDialog(usageDialogItems);
                dialog.ShowDialog();
                return((int)ExitCode.Success);
            }

            // Set output encoding to ansi because otherwise the output pane
            // of visual studio will display wrong characters.
            // TODO: Make this behaviour configurable.
            Console.OutputEncoding = Encoding.Default;
            ConsoleTraceListener traceListener = new ConsoleTraceListener();

            Trace.Listeners.Add(traceListener);

            CmdArgs cmdArgs             = new CmdArgs();
            bool    argumentsValid      = CommandLine.Parser.ParseArguments(args, cmdArgs);
            bool    didTraceCommandLine = false;

            VerbositySwitch verbosity = GlobalSettings.Verbosity;

            verbosity.Level = (TraceLevel)(cmdArgs.Verbose);

            ExitCode exitCode;

            ;
            if (!argumentsValid)
            {
                if (verbosity.TraceWarning)
                {
                    TraceCommandLine(args);
                    didTraceCommandLine = true;
                    string usage = CommandLine.Parser.ArgumentsUsage(cmdArgs.GetType());
                    Console.Write(usage);
                }
                exitCode = ExitCode.ArgumentsError;
            }
            else
            {
                verbosity.Level = (TraceLevel)cmdArgs.Verbose;
                if (verbosity.TraceVerbose)
                {
                    TraceCommandLine(args);
                    didTraceCommandLine = true;
                }
                Processor processor = null;
                try {
                    CSqlOptions csqlOptions = cmdArgs.CreateCsqlOptions();
                    processor = new Processor(csqlOptions);

                    processor.SignIn();

                    processor.Process();

                    processor.SignOut();

                    exitCode = ExitCode.Success;
                }
                catch (FileNotFoundException ex) {
                    if (!didTraceCommandLine && verbosity.TraceError)
                    {
                        TraceCommandLine(args);
                    }
                    Trace.WriteLineIf(verbosity.TraceError, ex.FileName + ": " + ex.Message);
                    exitCode = ExitCode.FileIOError;
                }
                catch (IOException ex) {
                    if (!didTraceCommandLine && verbosity.TraceError)
                    {
                        TraceCommandLine(args);
                    }
                    Trace.WriteLineIf(verbosity.TraceError, ex.Message);
                    exitCode = ExitCode.FileIOError;
                }
                catch (TerminateException ex) {
                    if (!didTraceCommandLine && verbosity.TraceError)
                    {
                        TraceCommandLine(args);
                    }
                    if (processor != null)
                    {
                        processor.SignOut();
                    }
                    exitCode = ex.ExitCode;
                }
                catch (Exception ex) {
                    if (!didTraceCommandLine && verbosity.TraceError)
                    {
                        TraceCommandLine(args);
                    }
                    Trace.WriteLineIf(verbosity.TraceError, "Unexpected error: " + ex);
                    exitCode = ExitCode.UnexpectedError;
                }
                finally {
                    Trace.Flush();
                    if (processor != null)
                    {
                        processor.Dispose();
                    }
                }
            }

            if (exitCode != ExitCode.Success && System.Diagnostics.Debugger.IsAttached)
            {
                Console.Write("Press any key to continue...");
                Console.ReadKey();
            }

            return((int)exitCode);
        }