DBTool for Oracle - Part 1

using System;
using System.Collections.Generic;
using System.Data;
using System.Text;

using Oracle.DataAccess.Client;
using Oracle.DataAccess.Types;

using System.Reflection;
using System.ComponentModel;
using Harlinn.Common;
using Harlinn.DBTool.Common;
using Harlinn.DBTool.DataSources.Oracle.DB;




namespace Harlinn.DBTool.DataSources.Oracle
{
    public class DBOracleFields : DBOracleElement, IDBColumns
    {
        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);
        }

        string qualifiedName;
        bool refreshed;

        public DBOracleFields()
        {
            
        }
        public DBOracleFields(NodeBase parent, string qualifiedName)
            : base(parent, "Fields")
        {
            this.qualifiedName = qualifiedName;
        }

        [Browsable(false)]
        public DBOracleTable Table
        {
            get
            {
                DBOracleTable result = Parent as DBOracleTable;
                return result;
            }
        }

        [Browsable(false)]
        public DBOracleView View
        {
            get
            {
                DBOracleView result = Parent as DBOracleView;
                return result;
            }
        }

        [Browsable(false)]
        public DBOracleField this[string name]
        {
            get
            {
                if (!refreshed)
                {
                    Refresh();
                }
                DBOracleField result = GetChildByName<DBOracleField>(name);
                return result;
            }
        }

        [Browsable(false)]
        public DBOracleField this[int index]
        {
            get
            {
                if (!refreshed)
                {
                    Refresh();
                }
                DBOracleField result = (DBOracleField)Children[index];
                return result;
            }
        }


        public override DBOracleElementType ElementType
        {
            get 
            {
                return DBOracleElementType.Fields;
            }
        }

        public override void Refresh()
        {
            try
            {
                base.Refresh();

                OracleConnection connection = ConnectionManager.Connection;
                OracleCommand command = connection.CreateCommand();
                using (command)
                {
                    command.CommandText = "SELECT * FROM " + qualifiedName;
                    OracleDataReader reader = command.ExecuteReader(CommandBehavior.SchemaOnly | CommandBehavior.KeyInfo);
                    using (reader)
                    {
                        DataTable schemaInfo = reader.GetSchemaTable();
                        foreach (DataRow fieldDefinition in schemaInfo.Rows)
                        {
                            DBOracleField field = new DBOracleField(this, fieldDefinition);
                            Children.Add(field);
                        }
                    }
                }
                refreshed = true;
            }
            catch (Exception exc)
            {
                LogException(exc, MethodBase.GetCurrentMethod());
                //throw;
            }
        }


        public IDBColumn GetColumnByName(string name)
        {
            if (!refreshed)
            {
                Refresh();
            }
            DBOracleField result = GetChildByName<DBOracleField>(name);
            return result;
        }

        public int IndexOf(IDBColumn item)
        {
            if (!refreshed)
            {
                Refresh();
            }
            return Children.IndexOf((DBOracleField)item);
        }

        public void Insert(int index, IDBColumn item)
        {
            if (!refreshed)
            {
                Refresh();
            }
            Children.Insert(index, (DBOracleField)item);
        }

        public void RemoveAt(int index)
        {
            if (!refreshed)
            {
                Refresh();
            }
            Children.RemoveAt(index);
        }

        IDBColumn IList<IDBColumn>.this[int index]
        {
            get
            {
                if (!refreshed)
                {
                    Refresh();
                }
                return (DBOracleField)Children[index];
            }
            set
            {
                if (!refreshed)
                {
                    Refresh();
                }
                Children[index] = (DBOracleField)value;
            }
        }

        public void Add(IDBColumn item)
        {
            if (!refreshed)
            {
                Refresh();
            }
            Children.Add((DBOracleField)item);
        }

        public bool Contains(IDBColumn item)
        {
            if (!refreshed)
            {
                Refresh();
            }
            return Children.Contains((DBOracleField)item);
        }

        public void CopyTo(IDBColumn[] array, int arrayIndex)
        {
            if (!refreshed)
            {
                Refresh();
            }
            for (int i = 0; i < Children.Count; i++)
            {
                if (array.Length > i + arrayIndex)
                {
                    array[i + arrayIndex] = (DBOracleField)Children[i];
                }
                else
                {
                    break;
                }
            }
        }

        public int Count
        {
            get 
            {
                if (!refreshed)
                {
                    Refresh();
                }
                return Children.Count;
            }
        }

        public bool IsReadOnly
        {
            get 
            {
                if (!refreshed)
                {
                    Refresh();
                }
                return ((IList<NodeBase>)Children).IsReadOnly;
            }
        }

        public bool Remove(IDBColumn item)
        {
            if (!refreshed)
            {
                Refresh();
            }
            return Children.Remove((DBOracleField)item);
        }

        private class InterfaceEnumerator : IEnumerator<IDBColumn>
        {
            IEnumerator<NodeBase> enumerator;

            public InterfaceEnumerator(IEnumerator<NodeBase> enumerator)
            {
                if (enumerator == null)
                {
                    throw new ArgumentNullException("enumerator");
                }
                this.enumerator = enumerator;
            }

            public IDBColumn Current
            {
                get
                {
                    return (IDBColumn)enumerator.Current;
                }
            }

            public void Dispose()
            {
                enumerator.Dispose();
            }

            object System.Collections.IEnumerator.Current
            {
                get
                {
                    return (object)enumerator.Current;
                }
            }

            public bool MoveNext()
            {
                return enumerator.MoveNext();
            }

            public void Reset()
            {
                enumerator.Reset();
            }
        }


        public IEnumerator<IDBColumn> GetEnumerator()
        {
            if (!refreshed)
            {
                Refresh();
            }
            return new InterfaceEnumerator(Children.GetEnumerator());
        }

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            if (!refreshed)
            {
                Refresh();
            }
            return ((System.Collections.IEnumerable)Children).GetEnumerator();
        }
    }
}