Example #1
0
        private void CheckConnection(object sender, RunWorkerCompletedEventArgs e)
        {
            UpdateControlUsage(true);

            if (e.Error != null)
            {
                string errorMsg = e.Error.Message.Replace(". ", "." + Environment.NewLine);
                Output.Current.Add("Error", errorMsg);
                XtraMessageBox.Show(this, errorMsg, e.Error.Source, MessageBoxButtons.OK, MessageBoxIcon.Error);
                boxServer.Focus();
                return;
            }

            using (SqlConnection connection = (SqlConnection)e.Result) {
                try {
                    _serverInfo = QueryEngine.GetServerInfo(connection);
                }
                catch (Exception ex) {
                    string errorMsg = ex.Message.Replace(". ", "." + Environment.NewLine);
                    Output.Current.Add("Error", errorMsg);
                    XtraMessageBox.Show(errorMsg, ex.Source, MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    return;
                }
                finally {
                    connection.Close();
                }
            }

            if (_serverInfo.MajorVersion < ServerVersion.Sql2008)
            {
                XtraMessageBox.Show(Resources.MinVersionMessage, "", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                boxServer.Focus();
            }
            else
            {
                DialogResult = DialogResult.OK;
            }
        }
Example #2
0
        public CmdWorker(List <CmdArgument> args)
        {
            Host host = new Host();

            Settings.Options.IgnorePermissions = false;
            Settings.Options.IgnoreReadOnlyFL  = false;

            foreach (CmdArgument cmd in args)
            {
                switch (cmd.Argument)
                {
                case "connection":
                    SqlConnectionStringBuilder sb = new SqlConnectionStringBuilder(cmd.Params[0]);
                    host.Server   = sb.DataSource;
                    host.AuthType = sb.IntegratedSecurity ? AuthTypes.Windows : AuthTypes.SqlServer;
                    host.User     = sb.UserID;
                    if (!string.IsNullOrEmpty(sb.InitialCatalog))
                    {
                        host.Databases.Add(sb.InitialCatalog);
                    }
                    if (!sb.IntegratedSecurity)
                    {
                        host.Password = sb.Password;
                    }
                    Settings.Options.ConnectionTimeout = sb.ConnectTimeout;
                    break;

                case "databases":
                    host.Databases.Clear();
                    List <string> dbs = new List <string> (cmd.Params[0].Split(';'));
                    host.Databases.AddRange(dbs.Where(_ => !string.IsNullOrEmpty(_)).Distinct());
                    break;

                case "connectiontimeout":
                    Settings.Options.ConnectionTimeout = Convert.ToInt32(cmd.Params[0]);
                    break;

                case "commandtimeout":
                    Settings.Options.CommandTimeout = Convert.ToInt32(cmd.Params[0]);
                    break;

                case "online":
                    Settings.Options.Online = true;
                    break;

                case "ignoreheap":
                    Settings.Options.ScanHeap = false;
                    break;

                case "ignorecolumnstore":
                    Settings.Options.ScanClusteredColumnstore    = false;
                    Settings.Options.ScanNonClusteredColumnstore = false;
                    break;

                case "ignorebtree":
                    Settings.Options.ScanClusteredIndex    = false;
                    Settings.Options.ScanNonClusteredIndex = false;
                    break;

                case "maxdop":
                    Settings.Options.MaxDop = Convert.ToInt32(cmd.Params[0]);
                    break;

                case "rebuildthreshold":
                    Settings.Options.RebuildThreshold = Convert.ToInt32(cmd.Params[0]);
                    break;

                case "reorganizethreshold":
                    Settings.Options.ReorganizeThreshold = Convert.ToInt32(cmd.Params[0]);
                    break;

                case "minindexsize":
                    Settings.Options.MinIndexSize = Convert.ToInt32(cmd.Params[0]);
                    break;

                case "predescribesize":
                    Settings.Options.PreDescribeSize = Convert.ToInt32(cmd.Params[0]);
                    break;

                case "maxindexsize":
                    Settings.Options.MaxIndexSize = Convert.ToInt32(cmd.Params[0]);
                    break;

                default:
                    throw new ArgumentException($"Unknown argument \"{cmd.Argument}\"");
                }
            }

            if (host.Databases.Count == 0)
            {
                throw new ArgumentException("No database selected");
            }

            using (SqlConnection connection = Connection.Create(host)) {
                try {
                    host.ServerInfo = QueryEngine.GetServerInfo(connection);
                }
                catch (Exception ex) {
                    throw new ArgumentException(ex.Message.Replace(". ", "." + Environment.NewLine));
                }
                finally {
                    connection.Close();
                }
            }

            if (host.ServerInfo.MajorVersion < Server.Sql2008)
            {
                throw new ArgumentException(Resources.MinVersionMessage);
            }
            else
            {
                Settings.ActiveHost = host;
            }
        }