using System;
using System.Collections.Generic;
using System.Text;
using System.Reflection;
using System.ComponentModel;
using Harlinn.Common;
using Harlinn.DBTool.DataSources.Oracle.DB;
namespace Harlinn.DBTool.DataSources.Oracle
{
public class DBOracleUserObjects : DBOracleElement
{
private static readonly log4net.ILog sfLog = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
private static void LogException(Exception exc, System.Reflection.MethodBase method)
{
Logger.LogException(sfLog, exc, method);
}
DBOracleClusters clusters;
DBOracleConsumerGroups consumerGroups;
DBOracleContexts contexts;
DBOracleDestinations destinations;
DBOracleDirectories directories;
DBOracleEditions editions;
DBOracleEvaluationContexts evaluationContexts;
DBOracleFunctions functions;
DBOracleIndexes indexes;
DBOracleIndexPartitions indexPartitions;
DBOracleIndexTypes indexTypes;
DBOracleJavaClasses javaClasses;
DBOracleJavaDatas javaData;
DBOracleJavaResources javaResources;
DBOracleJavaSources javaSources;
DBOracleJobs jobs;
DBOracleJobClasses jobClasses;
DBOracleLibraries libraries;
DBOracleMaterializedViews materializedViews;
DBOracleOperators operators;
DBOraclePackages packages;
DBOraclePackageBodies packageBodies;
DBOracleProcedures procedures;
DBOraclePrograms programs;
DBOracleRules rules;
DBOracleRuleSets ruleSets;
DBOracleSchedules schedules;
DBOracleSchedulerGroups schedulerGroups;
DBOracleSequences sequences;
DBOracleSynonyms synonyms;
DBOracleTables tables;
DBOracleTablePartitions tablePartitions;
DBOracleTriggers triggers;
DBOracleTypes types;
DBOracleTypeBodies typeBodies;
DBOracleViews views;
DBOracleWindows windows;
DBOracleXMLSchemas xmlSchemas;
bool refreshCalled;
public DBOracleUserObjects()
{
Initialize();
}
public DBOracleUserObjects(DBOracleUser parent)
: base(parent, "Objects")
{
Initialize();
}
private void Initialize()
{
refreshCalled = false;
clusters = new DBOracleClusters(this);
consumerGroups = new DBOracleConsumerGroups(this);
contexts = new DBOracleContexts(this);
destinations = new DBOracleDestinations(this);
directories = new DBOracleDirectories(this);
editions = new DBOracleEditions(this);
evaluationContexts = new DBOracleEvaluationContexts(this);
functions = new DBOracleFunctions(this);
indexes = new DBOracleIndexes(this);
indexPartitions = new DBOracleIndexPartitions(this);
indexTypes = new DBOracleIndexTypes(this);
javaClasses = new DBOracleJavaClasses(this);
javaData = new DBOracleJavaDatas(this);
javaResources = new DBOracleJavaResources(this);
javaSources = new DBOracleJavaSources(this);
jobs = new DBOracleJobs(this);
jobClasses = new DBOracleJobClasses(this);
libraries = new DBOracleLibraries(this);
materializedViews = new DBOracleMaterializedViews(this);
operators = new DBOracleOperators(this);
packages = new DBOraclePackages(this);
packageBodies = new DBOraclePackageBodies(this);
procedures = new DBOracleProcedures(this);
programs = new DBOraclePrograms(this);
rules = new DBOracleRules(this);
ruleSets = new DBOracleRuleSets(this);
schedules = new DBOracleSchedules(this);
schedulerGroups = new DBOracleSchedulerGroups(this);
sequences = new DBOracleSequences(this);
synonyms = new DBOracleSynonyms(this);
tables = new DBOracleTables(this);
tablePartitions = new DBOracleTablePartitions(this);
triggers = new DBOracleTriggers(this);
types = new DBOracleTypes(this);
typeBodies = new DBOracleTypeBodies(this);
views = new DBOracleViews(this);
windows = new DBOracleWindows(this);
xmlSchemas = new DBOracleXMLSchemas(this);
}
[Browsable(false)]
public DBOracleUser User
{
get
{
DBOracleUser result = (DBOracleUser)Parent;
return result;
}
}
private void ClearObjectCollections()
{
clusters.Clear();
consumerGroups.Clear();
contexts.Clear();
destinations.Clear();
directories.Clear();
editions.Clear();
evaluationContexts.Clear();
functions.Clear();
indexes.Clear();
indexPartitions.Clear();
indexTypes.Clear();
javaClasses.Clear();
javaData.Clear();
javaResources.Clear();
javaSources.Clear();
jobs.Clear();
jobClasses.Clear();
libraries.Clear();
materializedViews.Clear();
operators.Clear();
packages.Clear();
packageBodies.Clear();
procedures.Clear();
programs.Clear();
rules.Clear();
ruleSets.Clear();
schedules.Clear();
schedulerGroups.Clear();
sequences.Clear();
synonyms.Clear();
tables.Clear();
tablePartitions.Clear();
triggers.Clear();
types.Clear();
typeBodies.Clear();
views.Clear();
windows.Clear();
xmlSchemas.Clear();
}
private void AddObject(ObjectReader reader)
{
switch (reader.ObjectType)
{
case ObjectType.Edition:
editions.Children.Add(new DBOracleEdition(editions, reader));
break;
case ObjectType.IndexPartition:
indexPartitions.Children.Add(new DBOracleIndexPartition(indexPartitions, reader));
break;
case ObjectType.ConsumerGroup:
consumerGroups.Children.Add(new DBOracleConsumerGroup(consumerGroups, reader));
break;
case ObjectType.Sequence:
sequences.Children.Add(new DBOracleSequence(sequences, reader));
break;
case ObjectType.TablePartition:
tablePartitions.Children.Add(new DBOracleTablePartition(tablePartitions, reader));
break;
case ObjectType.Schedule:
schedules.Children.Add(new DBOracleSchedule(schedules, reader));
break;
case ObjectType.Rule:
rules.Children.Add(new DBOracleRule(rules, reader));
break;
case ObjectType.JavaData:
javaData.Children.Add(new DBOracleJavaData(javaData, reader));
break;
case ObjectType.Procedure:
procedures.Children.Add(new DBOracleProcedure(procedures, reader));
break;
case ObjectType.Operator:
operators.Children.Add(new DBOracleOperator(operators, reader));
break;
case ObjectType.Destination:
destinations.Children.Add(new DBOracleDestination(destinations, reader));
break;
case ObjectType.Window:
windows.Children.Add(new DBOracleWindow(windows, reader));
break;
case ObjectType.SchedulerGroup:
schedulerGroups.Children.Add(new DBOracleSchedulerGroup(schedulerGroups, reader));
break;
case ObjectType.Package:
packages.Children.Add(new DBOraclePackage(packages, reader));
break;
case ObjectType.PackageBody:
packageBodies.Children.Add(new DBOraclePackageBody(packageBodies, reader));
break;
case ObjectType.Library:
libraries.Children.Add(new DBOracleLibrary(libraries, reader));
break;
case ObjectType.Program:
programs.Children.Add(new DBOracleProgram(programs, reader));
break;
case ObjectType.RuleSet:
ruleSets.Children.Add(new DBOracleRuleSet(ruleSets, reader));
break;
case ObjectType.Context:
contexts.Children.Add(new DBOracleContext(contexts, reader));
break;
case ObjectType.TypeBody:
typeBodies.Children.Add(new DBOracleTypeBody(typeBodies, reader));
break;
case ObjectType.JavaResource:
javaResources.Children.Add(new DBOracleJavaResource(javaResources, reader));
break;
case ObjectType.XMLSchema:
xmlSchemas.Children.Add(new DBOracleXMLSchema(xmlSchemas, reader));
break;
case ObjectType.Trigger:
triggers.Children.Add(new DBOracleTrigger(triggers, reader));
break;
case ObjectType.JobClass:
jobClasses.Children.Add(new DBOracleJobClass(jobClasses, reader));
break;
case ObjectType.Directory:
directories.Children.Add(new DBOracleDirectory(directories, reader));
break;
case ObjectType.MaterializedView:
materializedViews.Children.Add(new DBOracleMaterializedView(materializedViews, reader));
break;
case ObjectType.Table:
tables.Children.Add(new DBOracleTable(tables, reader));
break;
case ObjectType.Index:
indexes.Children.Add(new DBOracleIndex(indexes, reader));
break;
case ObjectType.Synonym:
synonyms.Children.Add(new DBOracleSynonym(synonyms, reader));
break;
case ObjectType.View:
views.Children.Add(new DBOracleView(views, reader));
break;
case ObjectType.Function:
functions.Children.Add(new DBOracleFunction(functions, reader));
break;
case ObjectType.JavaClass:
javaClasses.Children.Add(new DBOracleJavaClass(javaClasses, reader));
break;
case ObjectType.JavaSource:
javaSources.Children.Add(new DBOracleJavaSource(javaSources, reader));
break;
case ObjectType.IndexType:
indexTypes.Children.Add(new DBOracleIndexType(indexTypes, reader));
break;
case ObjectType.Cluster:
clusters.Children.Add(new DBOracleCluster(clusters, reader));
break;
case ObjectType.Type:
types.Children.Add(new DBOracleType(types, reader));
break;
case ObjectType.Job:
jobs.Children.Add(new DBOracleJob(jobs, reader));
break;
case ObjectType.EvaluationContext:
evaluationContexts.Children.Add(new DBOracleEvaluationContext(evaluationContexts, reader));
break;
}
}
public override void Refresh()
{
base.Refresh();
try
{
refreshCalled = true;
ClearObjectCollections();
ObjectReader reader = ObjectReader.CreateObjectReader(User.Name);
using (reader)
{
while (reader.Read())
{
AddObject(reader);
}
}
if(clusters.Count > 0)
{
Children.Add(clusters);
}
if(consumerGroups.Count > 0)
{
Children.Add(consumerGroups);
}
if(contexts.Count > 0)
{
Children.Add(contexts);
}
if(destinations.Count > 0)
{
Children.Add(destinations);
}
if(directories.Count > 0)
{
Children.Add(directories);
}
if(editions.Count > 0)
{
Children.Add(editions);
}
if(evaluationContexts.Count > 0)
{
Children.Add(evaluationContexts);
}
if(functions.Count > 0)
{
Children.Add(functions);
}
if(indexes.Count > 0)
{
Children.Add(indexes);
}
if(indexPartitions.Count > 0)
{
Children.Add(indexPartitions);
}
if(indexTypes.Count > 0)
{
Children.Add(indexTypes);
}
if(javaClasses.Count > 0)
{
Children.Add(javaClasses);
}
if(javaData.Count > 0)
{
Children.Add(javaData);
}
if(javaResources.Count > 0)
{
Children.Add(javaResources);
}
if(javaSources.Count > 0)
{
Children.Add(javaSources);
}
if(jobs.Count > 0)
{
Children.Add(jobs);
}
if(jobClasses.Count > 0)
{
Children.Add(jobClasses);
}
if(libraries.Count > 0)
{
Children.Add(libraries);
}
if(materializedViews.Count > 0)
{
Children.Add(materializedViews);
}
if(operators.Count > 0)
{
Children.Add(operators);
}
if(packages.Count > 0)
{
Children.Add(packages);
}
if(packageBodies.Count > 0)
{
Children.Add(packageBodies);
}
if(procedures.Count > 0)
{
Children.Add(procedures);
}
if(programs.Count > 0)
{
Children.Add(programs);
}
if(rules.Count > 0)
{
Children.Add(rules);
}
if(ruleSets.Count > 0)
{
Children.Add(ruleSets);
}
if(schedules.Count > 0)
{
Children.Add(schedules);
}
if(schedulerGroups.Count > 0)
{
Children.Add(schedulerGroups);
}
if(sequences.Children.Count > 0)
{
Children.Add(sequences);
}
if(synonyms.Count > 0)
{
Children.Add(synonyms);
}
if(tables.Children.Count > 0)
{
Children.Add(tables);
}
if(tablePartitions.Count > 0)
{
Children.Add(tablePartitions);
}
if(triggers.Count > 0)
{
Children.Add(triggers);
}
if(types.Count > 0)
{
Children.Add(types);
}
if(typeBodies.Count > 0)
{
Children.Add(typeBodies);
}
if(views.Children.Count > 0)
{
Children.Add(views);
}
if(windows.Count > 0)
{
Children.Add(windows);
}
if (xmlSchemas.Count > 0)
{
Children.Add(xmlSchemas);
}
}
catch (Exception exc)
{
LogException(exc, MethodBase.GetCurrentMethod());
throw;
}
}
public DBOracleUserObject GetObject(ObjectType objectType, string objectName)
{
try
{
if (refreshCalled == false)
{
Refresh();
}
DBOracleUserObject result = null;
switch (objectType)
{
case ObjectType.Unknown:
break;
case ObjectType.Edition:
result = editions.GetChildByName<DBOracleUserObject>(objectName);
break;
case ObjectType.IndexPartition:
result = indexPartitions.GetChildByName<DBOracleUserObject>(objectName);
break;
case ObjectType.ConsumerGroup:
result = consumerGroups.GetChildByName<DBOracleUserObject>(objectName);
break;
case ObjectType.Sequence:
result = sequences.GetChildByName<DBOracleUserObject>(objectName);
break;
case ObjectType.TablePartition:
result = tablePartitions.GetChildByName<DBOracleUserObject>(objectName);
break;
case ObjectType.Schedule:
result = schedules.GetChildByName<DBOracleUserObject>(objectName);
break;
case ObjectType.Rule:
result = rules.GetChildByName<DBOracleUserObject>(objectName);
break;
case ObjectType.JavaData:
result = javaData.GetChildByName<DBOracleUserObject>(objectName);
break;
case ObjectType.Procedure:
result = procedures.GetChildByName<DBOracleUserObject>(objectName);
break;
case ObjectType.Operator:
result = operators.GetChildByName<DBOracleUserObject>(objectName);
break;
case ObjectType.Destination:
result = destinations.GetChildByName<DBOracleUserObject>(objectName);
break;
case ObjectType.Window:
result = windows.GetChildByName<DBOracleUserObject>(objectName);
break;
case ObjectType.SchedulerGroup:
result = schedulerGroups.GetChildByName<DBOracleUserObject>(objectName);
break;
case ObjectType.Package:
result = packages.GetChildByName<DBOracleUserObject>(objectName);
break;
case ObjectType.PackageBody:
result = packageBodies.GetChildByName<DBOracleUserObject>(objectName);
break;
case ObjectType.Library:
result = libraries.GetChildByName<DBOracleUserObject>(objectName);
break;
case ObjectType.Program:
result = programs.GetChildByName<DBOracleUserObject>(objectName);
break;
case ObjectType.RuleSet:
result = ruleSets.GetChildByName<DBOracleUserObject>(objectName);
break;
case ObjectType.Context:
result = contexts.GetChildByName<DBOracleUserObject>(objectName);
break;
case ObjectType.TypeBody:
result = typeBodies.GetChildByName<DBOracleUserObject>(objectName);
break;
case ObjectType.JavaResource:
result = javaResources.GetChildByName<DBOracleUserObject>(objectName);
break;
case ObjectType.XMLSchema:
result = xmlSchemas.GetChildByName<DBOracleUserObject>(objectName);
break;
case ObjectType.Trigger:
result = triggers.GetChildByName<DBOracleUserObject>(objectName);
break;
case ObjectType.JobClass:
result = jobClasses.GetChildByName<DBOracleUserObject>(objectName);
break;
case ObjectType.Directory:
result = directories.GetChildByName<DBOracleUserObject>(objectName);
break;
case ObjectType.MaterializedView:
result = materializedViews.GetChildByName<DBOracleUserObject>(objectName);
break;
case ObjectType.Table:
result = tables.GetChildByName<DBOracleUserObject>(objectName);
break;
case ObjectType.Index:
result = indexes.GetChildByName<DBOracleUserObject>(objectName);
break;
case ObjectType.Synonym:
result = synonyms.GetChildByName<DBOracleUserObject>(objectName);
break;
case ObjectType.View:
result = views.GetChildByName<DBOracleUserObject>(objectName);
break;
case ObjectType.Function:
result = functions.GetChildByName<DBOracleUserObject>(objectName);
break;
case ObjectType.JavaClass:
result = javaClasses.GetChildByName<DBOracleUserObject>(objectName);
break;
case ObjectType.JavaSource:
result = javaSources.GetChildByName<DBOracleUserObject>(objectName);
break;
case ObjectType.IndexType:
result = indexTypes.GetChildByName<DBOracleUserObject>(objectName);
break;
case ObjectType.Cluster:
result = clusters.GetChildByName<DBOracleUserObject>(objectName);
break;
case ObjectType.Type:
result = types.GetChildByName<DBOracleUserObject>(objectName);
break;
case ObjectType.Job:
result = jobs.GetChildByName<DBOracleUserObject>(objectName);
break;
case ObjectType.EvaluationContext:
result = evaluationContexts.GetChildByName<DBOracleUserObject>(objectName);
break;
}
return result;
}
catch (Exception exc)
{
LogException(exc, MethodBase.GetCurrentMethod());
throw;
}
}
public override DBOracleElementType ElementType
{
get
{
return DBOracleElementType.UserObjects;
}
}
[Browsable(false)]
public DBOracleClusters Clusters
{
get
{
if (refreshCalled == false)
{
Refresh();
}
return clusters;
}
}
[Browsable(false)]
public DBOracleConsumerGroups ConsumerGroups
{
get
{
if (refreshCalled == false)
{
Refresh();
}
return consumerGroups;
}
}
[Browsable(false)]
public DBOracleContexts Contexts
{
get
{
if (refreshCalled == false)
{
Refresh();
}
return contexts;
}
}
[Browsable(false)]
public DBOracleDestinations Destinations
{
get
{
if (refreshCalled == false)
{
Refresh();
}
return destinations;
}
}
[Browsable(false)]
public DBOracleDirectories Directories
{
get
{
if (refreshCalled == false)
{
Refresh();
}
return directories;
}
}
[Browsable(false)]
public DBOracleEditions Editions
{
get
{
if (refreshCalled == false)
{
Refresh();
}
return editions;
}
}
[Browsable(false)]
public DBOracleEvaluationContexts EvaluationContexts
{
get
{
if (refreshCalled == false)
{
Refresh();
}
return evaluationContexts;
}
}
[Browsable(false)]
public DBOracleFunctions Functions
{
get
{
if (refreshCalled == false)
{
Refresh();
}
return functions;
}
}
[Browsable(false)]
public DBOracleIndexes Indexes
{
get
{
if (refreshCalled == false)
{
Refresh();
}
return indexes;
}
}
[Browsable(false)]
public DBOracleIndexPartitions IndexPartitions
{
get
{
if (refreshCalled == false)
{
Refresh();
}
return indexPartitions;
}
}
[Browsable(false)]
public DBOracleIndexTypes IndexTypes
{
get
{
if (refreshCalled == false)
{
Refresh();
}
return indexTypes;
}
}
[Browsable(false)]
public DBOracleJavaClasses JavaClasses
{
get
{
if (refreshCalled == false)
{
Refresh();
}
return javaClasses;
}
}
[Browsable(false)]
public DBOracleJavaDatas JavaData
{
get
{
if (refreshCalled == false)
{
Refresh();
}
return javaData;
}
}
[Browsable(false)]
public DBOracleJavaResources JavaResources
{
get
{
if (refreshCalled == false)
{
Refresh();
}
return javaResources;
}
}
[Browsable(false)]
public DBOracleJavaSources JavaSources
{
get
{
if (refreshCalled == false)
{
Refresh();
}
return javaSources;
}
}
[Browsable(false)]
public DBOracleJobs Jobs
{
get
{
if (refreshCalled == false)
{
Refresh();
}
return jobs;
}
}
[Browsable(false)]
public DBOracleJobClasses JobClasses
{
get
{
if (refreshCalled == false)
{
Refresh();
}
return jobClasses;
}
}
[Browsable(false)]
public DBOracleLibraries Libraries
{
get
{
if (refreshCalled == false)
{
Refresh();
}
return libraries;
}
}
[Browsable(false)]
public DBOracleMaterializedViews MaterializedViews
{
get
{
if (refreshCalled == false)
{
Refresh();
}
return materializedViews;
}
}
[Browsable(false)]
public DBOracleOperators Operators
{
get
{
if (refreshCalled == false)
{
Refresh();
}
return operators;
}
}
[Browsable(false)]
public DBOraclePackages Packages
{
get
{
if (refreshCalled == false)
{
Refresh();
}
return packages;
}
}
[Browsable(false)]
public DBOraclePackageBodies PackageBodies
{
get
{
if (refreshCalled == false)
{
Refresh();
}
return packageBodies;
}
}
[Browsable(false)]
public DBOracleProcedures Procedures
{
get
{
if (refreshCalled == false)
{
Refresh();
}
return procedures;
}
}
[Browsable(false)]
public DBOraclePrograms Programs
{
get
{
if (refreshCalled == false)
{
Refresh();
}
return programs;
}
}
[Browsable(false)]
public DBOracleRules Rules
{
get
{
if (refreshCalled == false)
{
Refresh();
}
return rules;
}
}
[Browsable(false)]
public DBOracleRuleSets RuleSets
{
get
{
if (refreshCalled == false)
{
Refresh();
}
return ruleSets;
}
}
[Browsable(false)]
public DBOracleSchedules Schedules
{
get
{
if (refreshCalled == false)
{
Refresh();
}
return schedules;
}
}
[Browsable(false)]
public DBOracleSchedulerGroups SchedulerGroups
{
get
{
if (refreshCalled == false)
{
Refresh();
}
return schedulerGroups;
}
}
[Browsable(false)]
public DBOracleSequences Sequences
{
get
{
if (refreshCalled == false)
{
Refresh();
}
return sequences;
}
}
[Browsable(false)]
public DBOracleSynonyms Synonyms
{
get
{
if (refreshCalled == false)
{
Refresh();
}
return synonyms;
}
}
[Browsable(false)]
public DBOracleTables Tables
{
get
{
if (refreshCalled == false)
{
Refresh();
}
return tables;
}
}
[Browsable(false)]
public DBOracleTablePartitions TablePartitions
{
get
{
if (refreshCalled == false)
{
Refresh();
}
return tablePartitions;
}
}
[Browsable(false)]
public DBOracleTriggers Triggers
{
get
{
if (refreshCalled == false)
{
Refresh();
}
return triggers;
}
}
[Browsable(false)]
public DBOracleTypes Types
{
get
{
if (refreshCalled == false)
{
Refresh();
}
return types;
}
}
[Browsable(false)]
public DBOracleTypeBodies TypeBodies
{
get
{
if (refreshCalled == false)
{
Refresh();
}
return typeBodies;
}
}
[Browsable(false)]
public DBOracleViews Views
{
get
{
if (refreshCalled == false)
{
Refresh();
}
return views;
}
}
[Browsable(false)]
public DBOracleWindows Windows
{
get
{
if (refreshCalled == false)
{
Refresh();
}
return windows;
}
}
[Browsable(false)]
public DBOracleXMLSchemas XMLSchemas
{
get
{
if (refreshCalled == false)
{
Refresh();
}
return xmlSchemas;
}
}
}
}
Submit an article or tip