void LoadObjects(Database d, IDatabaseDictionary databaseDictionary)
{
if (!d.IsSystemObject && d.IsAccessible)
{
try
{
var analyzer = new PerformanceAnalyzer();
LoadTables(d, databaseDictionary);
log.Performance("Loading tables " + d.Name, analyzer.Result);
LoadStoredProcs(d, databaseDictionary);
log.Performance("Loading procedures " + d.Name, analyzer.Result);
LoadViews(d, databaseDictionary);
log.Performance("Loading views " + d.Name, analyzer.Result);
LoadFunctions(d, databaseDictionary);
log.Performance("Loading functions " + d.Name, analyzer.Result);
analyzer.Stop();
}
catch (Exception ex)
{
// this can get thrown for security reasons - probably need to swallow here
log.Error("Security Error in database: " + d.Name, ex);
}
}
}
void FillDatabase(IDatabaseDictionary databaseDictionary)
{
var analyzer = new PerformanceAnalyzer();
Database d = null;
if (server.Databases.Contains(databaseDictionary.DatabaseName))
{
d = server.Databases[databaseDictionary.DatabaseName];
}
else
{
log.Error("Database name could not be found: " + databaseDictionary.DatabaseName + "; loader failed");
return;
}
databaseDictionary.Clear();
// do not need to refresh database RefresDatabase(d);
log.Performance("Refreshing database " + databaseDictionary.DatabaseName, analyzer.Result);
LoadObjects(d, databaseDictionary);
databaseDictionary.MarkAsLoaded();
log.Performance("Loading database " + databaseDictionary.DatabaseName, analyzer.Result);
analyzer.Stop();
}
private void LoadTables(Database d, IDatabaseDictionary databaseDictionary)
{
foreach (Table t in d.Tables)
{
try
{
if (!t.IsSystemObject)
{
databaseDictionary.Add(d, t, connectionInfo);
}
}
catch (Exception ex)
{
log.Error("Error loading table " + t.Name + " from db " + d.Name, ex);
}
}
}
private void LoadStoredProcs(Database d, IDatabaseDictionary databaseDictionary)
{
foreach (StoredProcedure p in d.StoredProcedures)
{
try
{
if (!p.IsSystemObject)
{
databaseDictionary.Add(d, p, connectionInfo);
}
}
catch (Exception ex)
{
log.Error("Error loading procedure " + p.Name + " from db " + d.Name, ex);
}
}
}
private void LoadViews(Database d, IDatabaseDictionary databaseDictionary)
{
foreach (View v in d.Views)
{
try
{
if (!v.IsSystemObject)
{
databaseDictionary.Add(d, v, connectionInfo);
}
}
catch (Exception ex)
{
log.Error("Error loading view " + v.Name + " from db " + d.Name, ex);
}
}
}
private void LoadFunctions(Database d, IDatabaseDictionary databaseDictionary)
{
foreach (UserDefinedFunction f in d.UserDefinedFunctions)
{
try
{
if (!f.IsSystemObject)
{
databaseDictionary.Add(d, f, connectionInfo);
}
}
catch (Exception ex)
{
log.Error("Error loading view " + f.Name + " from db " + d.Name, ex);
}
}
}
public void TestParentNodesDictionary()
{
Context ctx = new Context(typeof(IDatabaseDictionary));
using (var ws = ctx.OpenWorkspace <IDatabaseDictionary>(IsolationLevel.Exclusive))
{
IDatabaseDictionary database = ws.Data;
var person = ws.New <IPersonDictionary>();
person.Name = "John Connor";
person.Computers = ws.New <IDictionary <String, IComputer> >();
person.ComputersWithParent = ws.New <IDictionary <String, IComputer> >();
IComputer computer = ws.New <IComputer>();
computer.Model = "PC1";
person.Computers.Add(computer.Model, computer);
computer = ws.New <IComputer>();
computer.Model = "PC2";
person.Computers.Add(computer.Model, computer);
computer = ws.New <IComputer>();
computer.Model = "PC1 with parent";
person.ComputersWithParent.Add(computer.Model, computer);
computer = ws.New <IComputer>();
computer.Model = "PC2 with parent";
person.ComputersWithParent.Add(computer.Model, computer);
database.Person = person;
Assert.AreEqual("John Connor", database.Person.Name);
Assert.AreEqual(2, database.Person.Computers.Count);
Assert.IsTrue(database.Person.Computers.Values.Any(comp => comp.Model.Equals("PC1")));
Assert.IsTrue(database.Person.Computers.Values.Any(comp => comp.Model.Equals("PC2")));
Assert.AreEqual(0, ws.ParentNodes(database.Person.Computers.Values.ElementAt(0)).Count);
Assert.AreEqual(0, ws.ParentNodes(database.Person.Computers.Values.ElementAt(1)).Count);
Assert.AreEqual(2, database.Person.ComputersWithParent.Count);
Assert.IsTrue(database.Person.ComputersWithParent.Values.Any(comp => comp.Model.Equals("PC1 with parent")));
Assert.IsTrue(database.Person.ComputersWithParent.Values.Any(comp => comp.Model.Equals("PC2 with parent")));
Assert.AreEqual(0, ws.ParentNodes(database.Person.ComputersWithParent.Values.ElementAt(0)).Count);
Assert.AreEqual(0, ws.ParentNodes(database.Person.ComputersWithParent.Values.ElementAt(1)).Count);
ws.Commit();
}
using (var ws = ctx.OpenWorkspace <IDatabaseDictionary>(IsolationLevel.Exclusive))
{
IDatabaseDictionary database = ws.Data;
Assert.AreEqual("John Connor", database.Person.Name);
Assert.AreEqual(2, database.Person.Computers.Count);
Assert.IsTrue(database.Person.Computers.Values.Any(comp => comp.Model.Equals("PC1")));
Assert.IsTrue(database.Person.Computers.Values.Any(comp => comp.Model.Equals("PC2")));
Assert.AreEqual(0, ws.ParentNodes(database.Person.Computers.Values.ElementAt(0)).Count);
Assert.AreEqual(0, ws.ParentNodes(database.Person.Computers.Values.ElementAt(1)).Count);
Assert.AreEqual(2, database.Person.ComputersWithParent.Count);
Assert.IsTrue(database.Person.ComputersWithParent.Values.Any(comp => comp.Model.Equals("PC1 with parent")));
Assert.IsTrue(database.Person.ComputersWithParent.Values.Any(comp => comp.Model.Equals("PC2 with parent")));
ICollection <object> parentNodes = ws.ParentNodes(database.Person.ComputersWithParent.Values.ElementAt(0));
Assert.AreEqual(1, parentNodes.Count);
Assert.IsTrue(parentNodes.ElementAt(0) is IPersonDictionary);
parentNodes = ws.ParentNodes(database.Person.ComputersWithParent.Values.ElementAt(1));
Assert.AreEqual(1, parentNodes.Count);
Assert.IsTrue(parentNodes.ElementAt(0) is IPersonDictionary);
}
}
