private IDatabase GetDatabase(IDatabaseConnector databaseConnector, out IDatabaseLoader databaseLoader, List <SchemaData> tablesToFetch)
        {
            databaseLoader = null;
            _progress.SetCurrentState("Loading Database From Connection String in NHibernate Config File", ProgressState.Normal);

            databaseLoader = DatabaseLoaderFacade.GetDatabaseLoader(databaseConnector);
            databaseLoader.DatabaseObjectsToFetch = tablesToFetch;

            IDatabase database = null;
            bool      success  = false;

            while (success == false)
            {
                try
                {
                    database = databaseLoader.LoadDatabase(databaseLoader.DatabaseObjectsToFetch, null);
                    new DatabaseProcessor().CreateRelationships(database);
                    success = true;
                }
                catch (DatabaseLoaderException e)
                {
                    var loader = _userInteractor.GetDatabaseLoader(databaseConnector);
                    if (loader == null)
                    {
                        throw new NHibernateConfigException("Could not load the database specified in your config file.", e);
                    }
                    databaseLoader = loader;
                    _progress.SetCurrentState("Loading Database From Connection Information Given", ProgressState.Normal);
                }
            }
            return(database);
        }
Exemple #2
0
        private void RefreshSchema()
        {
            // Note: this is only ok because this method only runs on the UI thread.
            // Two instances of it will not run at once, so this is not a race condition.
            // The moment it can run from another thread, this assumption is false and the
            // code is incorrect.
            if (RefreshingSchema)
            {
                return;
            }

            databaseLock.WaitOne();

            RefreshingSchema = true;
            IDatabaseLoader loader = CreateDatabaseLoader(form);

            // Test connection first
            if (TestConnection(false) == false)
            {
                databaseLock.Set();
                return;
            }

            Thread thread = new Thread(
                () =>
            {
                try
                {
                    IDatabase newDb = loader.LoadDatabase(loader.DatabaseObjectsToFetch, null);
                    new DatabaseProcessor().CreateRelationships(newDb);

                    if (Database == null || Database.IsEmpty)
                    {
                        Database          = newDb;
                        DatabaseConnector = loader.DatabaseConnector;
                        NewDatabaseCreated.RaiseEvent(this);
                        return;
                    }

                    var result = new DatabaseProcessor().MergeDatabases(Database, newDb);
                    if (result.AnyChanges)
                    {
                        mainPanel.ShowDatabaseRefreshResults(result, Database, newDb);
                        SchemaRefreshed.RaiseEvent(this);
                    }
                    else
                    {
                        form.SetDatabaseOperationResults(new DatabaseOperationResults("Schema Refresh", true, "No schema changes detected."));
                    }
                }
                finally
                {
                    databaseLock.Set();
                    RefreshingSchema = false;
                }
            });

            thread.Start();
        }
Exemple #3
0
        private void Save()
        {
            if (_Database.ConnectionInformation == null)
            {
                IDatabaseLoader dbLoader = DatabasePresenter.CreateDatabaseLoader(ucDatabaseInformation1);

                try
                {
                    _Database = dbLoader.LoadDatabase(dbLoader.DatabaseObjectsToFetch, null);
                }
                catch (DatabaseLoaderException e)
                {
                    #region Save what we can
                    _Database.DatabaseType = ucDatabaseInformation1.SelectedDatabaseType;

                    _Database.ConnectionInformation          = new Helper.ConnectionStringHelper();
                    _Database.ConnectionInformation.FileName = ucDatabaseInformation1.ConnectionStringHelper.FileName;
                    _Database.ConnectionInformation.UseIntegratedSecurity = ucDatabaseInformation1.ConnectionStringHelper.UseIntegratedSecurity;
                    _Database.ConnectionInformation.UserName    = ucDatabaseInformation1.ConnectionStringHelper.UserName;
                    _Database.ConnectionInformation.Password    = ucDatabaseInformation1.ConnectionStringHelper.Password;
                    _Database.ConnectionInformation.Port        = ucDatabaseInformation1.ConnectionStringHelper.Port;
                    _Database.ConnectionInformation.ServerName  = ucDatabaseInformation1.ConnectionStringHelper.ServerName;
                    _Database.ConnectionInformation.ServiceName = ucDatabaseInformation1.ConnectionStringHelper.ServiceName;
                    #endregion

                    //if (e.InnerException != null && e.InnerException.Message.StartsWith("Database cannot be null, the empty string, or string of only whitespace."))
                    //    return;
                    //else
                    //    throw;
                }
            }
            else
            {
                //_Database.Name = ucDatabaseInformation1.ConnectionStringHelper.DatabaseName;
                _Database.DatabaseType = ucDatabaseInformation1.SelectedDatabaseType;
                var connStringHelper = ucDatabaseInformation1.ConnectionStringHelper;

                _Database.ConnectionInformation.FileName = connStringHelper.FileName;
                _Database.ConnectionInformation.UseIntegratedSecurity = connStringHelper.UseIntegratedSecurity;
                _Database.ConnectionInformation.UserName    = connStringHelper.UserName;
                _Database.ConnectionInformation.Password    = connStringHelper.Password;
                _Database.ConnectionInformation.Port        = connStringHelper.Port;
                _Database.ConnectionInformation.ServerName  = connStringHelper.ServerName;
                _Database.ConnectionInformation.ServiceName = connStringHelper.ServiceName;
            }
        }
        public void A_SQLCEDatabaseLoader_Is_Returned()
        {
            IDatabaseForm form  = MockRepository.GenerateMock <IDatabaseForm>();
            IMainPanel    panel = MockRepository.GenerateMock <IMainPanel>();

            DatabasePresenter presenter = new DatabasePresenter(panel, form);

            form.Stub(t => t.SelectedDatabaseType).Return(DatabaseTypes.SQLCE);
            form.Stub(t => t.SelectedDatabase).Return("1Table3Columns.sdf");

            IDatabaseLoader loader = presenter.CreateDatabaseLoader();

            Assert.That(loader, Is.Not.Null);
            Assert.That(loader, Is.TypeOf(typeof(SQLCEDatabaseLoader)));

            // Will throw an error if the database connection could not be established.
            loader.TestConnection();

            IDatabase db = loader.LoadDatabase();

            Assert.That(db.Name, Is.EqualTo("1Table3Columns"));
            Assert.That(db.Tables, Has.Count(1));             // Basic check to see if we got the correct database back.
        }
Exemple #5
0
        private void Populate()
        {
            nodeNewTables.Nodes.Clear();
            advTreeTables.BeginUpdate();

            try
            {
                // Fetch all schemas for
                IDatabaseLoader loader = FormDatabase.Instance.CreateDatabaseLoader();
                IDatabase       newDb  = loader.LoadDatabase(loader.DatabaseObjectsToFetch, null);

                foreach (var schema in newDb.Tables.Select(s => s.Schema).Distinct().Where(s => !ExistingSchemas.Contains(s)).OrderBy(s => s))
                {
                    Node schemaNode = new Node(schema)
                    {
                        CheckBoxVisible = true,
                        Checked         = false
                    };
                    nodeNewTables.Nodes.Add(schemaNode);

                    foreach (var table in newDb.Tables.Where(t => t.Schema == schema).Select(t => t.Name).OrderBy(t => t))
                    {
                        Node tableNode = new Node(table)
                        {
                            CheckBoxVisible = true,
                            Checked         = false
                        };
                        schemaNode.Nodes.Add(tableNode);
                    }
                }
            }
            finally
            {
                advTreeTables.EndUpdate();
            }
        }
Exemple #6
0
        private void RefreshSchema()
        {
            // Note: this is only ok because this method only runs on the UI thread.
            // Two instances of it will not run at once, so this is not a race condition.
            // The moment it can run from another thread, this assumption is false and the
            // code is incorrect.
            if (RefreshingSchema)
            {
                return;
            }

            Cursor = Cursors.WaitCursor;
            databaseLock.WaitOne();
            RefreshingSchema = true;
            IDatabaseLoader loader = CreateDatabaseLoader();

            // Test connection first
            if (TestConnection(false) == false)
            {
                databaseLock.Set();
                RefreshingSchema = false;
                Cursor           = Cursors.Default;
                return;
            }
            labelNoChanges.Visible       = false;
            labelNoChangesExport.Visible = false;

            Thread thread = new Thread(
                () =>
            {
                try
                {
                    List <string> schemasToLimit = Database.Tables.Union(Database.Views).Select(t => t.Schema).Distinct().ToList();
                    IDatabase newDb = loader.LoadDatabase(loader.DatabaseObjectsToFetch, schemasToLimit);
                    new DatabaseProcessor().CreateRelationships(newDb);

                    if (Database.Name == "New Database" && Database.Tables.Count == 0)
                    {
                        var mappingSet = new EntityModel.Controller.MappingLayer.MappingProcessor(new EntityModel.Controller.MappingLayer.OneToOneEntityProcessor())
                                         .CreateOneToOneMapping(newDb, Database.MappingSet.TablePrefixes, Database.MappingSet.ColumnPrefixes, Database.MappingSet.TableSuffixes, Database.MappingSet.ColumnSuffixes);

                        MappingSet = mappingSet;
                        _Database  = newDb;

                        if (NewDatabaseCreated != null)
                        {
                            NewDatabaseCreated(mappingSet);
                        }
                    }
                    else
                    {
                        var result = new DatabaseProcessor().MergeDatabases(Database, newDb);

                        if (result.AnyChanges)
                        {
                            databaseChanges1.Fill(result, Database, newDb);
                            modelChanges1.Fill(result, Database, newDb);
                            SetControlEnabled(buttonImport, true);
                        }
                        else
                        {
                            ShowNoChangesLabel();
                        }
                    }
                }
                finally
                {
                    databaseLock.Set();
                    RefreshingSchema = false;
                    SetCursor(Cursors.Default);
                }
            });

            thread.Start();
        }
Exemple #7
0
        protected override void DoRun(IJobRunEnv env)
        {
            IDatabaseLoader loader = m_backup.GetLoader(m_dst);

            loader.LoadDatabase(m_dst);
        }
        private IDatabase GetDatabase(IDatabaseConnector databaseConnector, out IDatabaseLoader databaseLoader, List<SchemaData> tablesToFetch)
        {
            databaseLoader = null;
            _progress.SetCurrentState("Loading Database From Connection String in NHibernate Config File", ProgressState.Normal);

            databaseLoader = DatabaseLoaderFacade.GetDatabaseLoader(databaseConnector);
            databaseLoader.DatabaseObjectsToFetch = tablesToFetch;

            IDatabase database = null;
            bool success = false;

            while (success == false)
            {
                try
                {
                    database = databaseLoader.LoadDatabase(databaseLoader.DatabaseObjectsToFetch, null);
                    new DatabaseProcessor().CreateRelationships(database);
                    success = true;
                }
                catch (DatabaseLoaderException e)
                {
                    var loader = _userInteractor.GetDatabaseLoader(databaseConnector);
                    if (loader == null)
                        throw new NHibernateConfigException("Could not load the database specified in your config file.", e);
                    databaseLoader = loader;
                    _progress.SetCurrentState("Loading Database From Connection Information Given", ProgressState.Normal);
                }
            }
            return database;
        }