Example #1
0
        //
        // DoGetSchemaItems + support methods
        //

        #region protected override IEnumerable<DBSchemaItemRef> DoGetSchemaItems(DBSchemaTypes types)

        protected override IEnumerable <DBSchemaItemRef> DoGetSchemaItems(DBSchemaTypes types)
        {
            List <DBSchemaItemRef> items = new List <DBSchemaItemRef>();

            using (DbConnection con = this.Database.CreateConnection())
            {
                con.Open();
                if (IsSchemaType(types, DBSchemaTypes.Table))
                {
                    this.LoadTableRefs(con, items);
                }
                if (IsSchemaType(types, DBSchemaTypes.View))
                {
                    this.LoadViewRefs(con, items);
                }
                if (IsSchemaType(types, DBSchemaTypes.Index))
                {
                    this.LoadIndexRefs(con, items);
                }
                if (IsSchemaType(types, DBSchemaTypes.StoredProcedure))
                {
                    this.LoadSprocRefs(con, items);
                }
            }

            return(items);
        }
 public override void BeginCheckExists(DBSchemaTypes type, string owner, string name)
 {
     if (type == DBSchemaTypes.StoredProcedure)
     {
         throw new NotSupportedException(string.Format(Errors.DatabaseEngineDoesntSupportType, type));
     }
 }
        public override void BeginCreate(DBSchemaTypes type, string owner, string name, string options, bool checknotexists)
        {
            if (type == DBSchemaTypes.StoredProcedure)
            {
                throw new NotSupportedException(string.Format(Errors.DatabaseEngineDoesntSupportType, type));
            }

            bool isconstraint = this.IsConstraintType(type);

            if (isconstraint && !string.IsNullOrEmpty(name))
            {
                this.WriteRawSQLString("CONSTRAINT ");
                this.BeginIdentifier();
                this.WriteObjectName(name);
                this.EndIdentifier();
                this.WriteSpace();
            }

            this.BeginCreate(type, options);

            if (checknotexists)
            {
                this.WriteCheckNotExists(type, owner, name);
            }

            if (!isconstraint)
            {
                this.WriteSourceTable(owner, name, string.Empty);
            }
        }
        public override void BeginCreate(DBSchemaTypes type, string owner, string name, string options, bool checknotexists)
        {
            if (type == DBSchemaTypes.StoredProcedure)
            {
                throw new NotSupportedException(string.Format(Errors.DatabaseEngineDoesntSupportType, type));
            }

            if (checknotexists)
            {
                throw new InvalidOperationException(String.Format(Errors.DBDoesntSupportIfExistsForThisType, "MS Access", type));
            }

            if (type == DBSchemaTypes.ForeignKey && !string.IsNullOrEmpty(name))
            {
                this.WriteRawSQLString("CONSTRAINT ");
                this.BeginIdentifier();
                this.WriteObjectName(name);
                this.EndIdentifier();
                this.WriteSpace();
            }

            this.BeginCreate(type, options);

            if (checknotexists)
            {
                base.EndCheckNotExists(type, owner, name);
            }


            if (type != DBSchemaTypes.ForeignKey)
            {
                this.WriteSourceTable(owner, name, string.Empty);
            }
        }
 public override void BeginCheckNotExists(DBSchemaTypes type, string owner, string name)
 {
     if (type == DBSchemaTypes.Index || type == DBSchemaTypes.View)
     {
         throw new ArgumentOutOfRangeException("checknotexisits", string.Format(Errors.DBDoesntSupportIfExistsForThisType, "MySQL", type));
     }
 }
Example #6
0
        //
        // .ctor
        //

        #region internal protected DBDatabaseProperties(...)

        /// <summary>
        /// Creates a new instance of the DBDatabaseProperties
        /// </summary>
        /// <param name="databaseName"></param>
        /// <param name="productName"></param>
        /// <param name="productLevel"></param>
        /// <param name="serverEdition"></param>
        /// <param name="parameterFormat"></param>
        /// <param name="version"></param>
        /// <param name="supports"></param>
        /// <param name="caseSensitive"></param>
        /// <param name="layout"></param>
        /// <param name="supportedDbTypes"></param>
        /// <param name="supportedTopTypes"></param>
        internal protected DBDatabaseProperties(string databaseName,
                                                string productName,
                                                string productLevel,
                                                string serverEdition,
                                                string parameterFormat,
                                                Version version,
                                                DBSchemaTypes supports,
                                                bool caseSensitive,
                                                DBParameterLayout layout,
                                                System.Data.DbType[] supportedDbTypes,
                                                TopType[] supportedTopTypes,
                                                Schema.DBSchemaInformation schemaInfo,
                                                TypedOperationCollection unsupportedOps)
        {
            this._vers              = version;
            this._edition           = serverEdition;
            this._productlevel      = productLevel;
            this._name              = productName;
            this._paramformat       = parameterFormat;
            this.SupportedSchemas   = supports;
            this.CaseSensitiveNames = caseSensitive;
            this.ParameterLayout    = layout;
            this.SupportedDbTypes   = supportedDbTypes;
            this.SupportedTopTypes  = supportedTopTypes;
            this._schemainfo        = schemaInfo;
            this._unsupportedOps    = unsupportedOps;
        }
Example #7
0
 /// <summary>
 /// Creates a new schema item with the specified values
 /// </summary>
 /// <param name="type"></param>
 /// <param name="schema"></param>
 /// <param name="name"></param>
 public DBSchemaItemRef(DBSchemaTypes type, string schema, string name)
     : this(type, string.Empty, schema, name)
 {
     this.Type   = type;
     this.Schema = schema;
     this.Name   = name;
 }
Example #8
0
 /// <summary>
 /// Creates a new schema item with the specified values
 /// </summary>
 /// <param name="type"></param>
 /// <param name="catalog"></param>
 /// <param name="schema"></param>
 /// <param name="name"></param>
 public DBSchemaItemRef(DBSchemaTypes type, string catalog, string schema, string name)
 {
     this.Type    = type;
     this.Catalog = catalog;
     this.Schema  = schema;
     this.Name    = name;
 }
Example #9
0
        //
        // public properties
        //

        #region public DBSchemaItem this[DBSchemaTypes type, string owner, string name] {get;}

        /// <summary>
        /// Gets the specifed DBSchemaItem in this collection that
        /// has the type, owner and name specified
        /// </summary>
        /// <param name="type"></param>
        /// <param name="owner"></param>
        /// <param name="name"></param>
        /// <returns></returns>
        public DBSchemaItem this[DBSchemaTypes type, string owner, string name]
        {
            get
            {
                DBSchemaItemRef iref = new DBSchemaItemRef(type, owner, name);
                return(this[iref]);
            }
        }
Example #10
0
        /// <summary>
        /// Calculates and returns the integer hashcode which
        /// should be unique for any combination of type and operation
        /// </summary>
        /// <param name="type"></param>
        /// <param name="op"></param>
        /// <returns></returns>
        public static int GetHashCode(DBSchemaTypes type, DBSchemaOperation op)
        {
            int val = (int)type;

            val  = val << 16;
            val += (int)op;
            return(val);
        }
        public DBSchemaInfoLookup GetListLookup(DBSchemaTypes type)
        {
            DBSchemaInfoLookup value;

            if (!_listlookup.TryGetValue(type, out value))
            {
                value = null;
            }
            return(value);
        }
        public override void EndCreate(DBSchemaTypes type, bool checknotexists)
        {
            if (type == DBSchemaTypes.Table)
            {
                this.WriteRawSQLString(" ENGINE = ");
                this.WriteObjectName(this.TableEngine);
            }

            this.DecrementStatementDepth();
        }
        public override void EndCreate(DBSchemaTypes type, bool checknotexists)
        {
            //Special case where the CREATE VIEW .. AS cannot have parenthese after - causes exception
            if (type == DBSchemaTypes.View)
            {
                this.IncrementStatementDepth();
            }

            base.EndCreate(type, checknotexists);
        }
Example #14
0
 /// <summary>
 /// Extends to support SEQUENCEs
 /// </summary>
 /// <param name="type"></param>
 protected override void WriteDropType(DBSchemaTypes type)
 {
     if (type == DBSchemaTypes.Sequence)
     {
         this.WriteDropType("SEQUENCE");
     }
     else
     {
         base.WriteDropType(type);
     }
 }
Example #15
0
 /// <summary>
 /// Check if this database supports a specific operation on the database.
 /// </summary>
 /// <param name="schema"></param>
 /// <param name="op"></param>
 /// <returns></returns>
 public bool CheckSupports(DBSchemaTypes schema, DBSchemaOperation op)
 {
     if (this.UnsupportedOps.Contains(schema, op))
     {
         return(false);
     }
     else
     {
         return(CheckSupports(schema));
     }
 }
Example #16
0
 /// <summary>
 /// Extends to Support SEQUENCEs
 /// </summary>
 /// <param name="type"></param>
 /// <param name="options"></param>
 /// <param name="isconstraint"></param>
 protected override void WriteCreateType(DBSchemaTypes type, string options, bool isconstraint)
 {
     if (type == DBSchemaTypes.Sequence)
     {
         string native = "SEQUENCE";
         this.WriteCreateType(native, options, isconstraint);
     }
     else
     {
         base.WriteCreateType(type, options, isconstraint);
     }
 }
        public override void BeginDropStatement(DBSchemaTypes type, string owner, string name, bool checkExists)
        {
            if (type == DBSchemaTypes.StoredProcedure)
            {
                throw new NotSupportedException(string.Format(Errors.DatabaseEngineDoesntSupportType, type));
            }

            if (checkExists)
            {
                throw new InvalidOperationException(String.Format(Errors.DBDoesntSupportIfExistsForThisType, "MS Access", type));
            }

            base.BeginDropStatement(type, owner, name, checkExists);
        }
Example #18
0
        /// <summary>
        /// Returns true if this collection contains a TypedOperation that matches the parameters
        /// </summary>
        /// <param name="type"></param>
        /// <param name="operation"></param>
        /// <returns></returns>
        public bool Contains(DBSchemaTypes type, DBSchemaOperation operation)
        {
            TypedOperation value;
            int            hash = TypedOperation.GetHashCode(type, operation);

            if (_ops.TryGetValue(hash, out value))
            {
                return(true);
            }
            else
            {
                return(false);
            }
        }
Example #19
0
        //
        // public methods
        //

        #region public IEnumerable<DBSchemaItem> GetAllItemsOfType(DBSchemaTypes type)

        /// <summary>
        /// Gets All the DBSchemaItems in the collection that are the specified type
        /// </summary>
        /// <param name="type"></param>
        /// <returns></returns>
        public IEnumerable <DBSchemaItem> GetAllItemsOfType(DBSchemaTypes type)
        {
            List <DBSchemaItem> list = new List <DBSchemaItem>();

            foreach (DBSchemaItem item in this)
            {
                if ((item.Type & type) > 0)
                {
                    list.Add(item);
                }
            }

            return(list.AsReadOnly());
        }
        public override void BeginCreate(DBSchemaTypes type, string options)
        {
            if (type == DBSchemaTypes.StoredProcedure)
            {
                throw new NotSupportedException(string.Format(Errors.DatabaseEngineDoesntSupportType, type));
            }

            base.BeginCreate(type, options);

            //Special case where the CREATE VIEW .. AS cannot have parenthese after - causes exception
            if (type == DBSchemaTypes.View)
            {
                this.DecrementStatementDepth();
            }
        }
Example #21
0
        private void FillSchema(Dictionary <string, Dictionary <DBSchemaTypes, List <DBSchemaItemRef> > > byschema)
        {
            Dictionary <DBSchemaTypes, List <DBSchemaItemRef> > schema;


            List <DBSchemaItemRef> items = new List <DBSchemaItemRef>();

            IEnumerable <DBSchemaItemRef> tbls = FillAllReferencesAndReturnTables(items);

            foreach (DBSchemaItemRef item in items)
            {
                System.Diagnostics.Debug.WriteLine(item.ToString());
                string schemaname;

                if (string.IsNullOrEmpty(item.Schema))
                {
                    schemaname = string.Empty;
                }
                else
                {
                    schemaname = item.Schema;
                }

                if (byschema.TryGetValue(schemaname, out schema) == false)
                {
                    schema = new Dictionary <DBSchemaTypes, List <DBSchemaItemRef> >();
                    byschema.Add(schemaname, schema);
                }

                DBSchemaTypes          type = item.Type;
                List <DBSchemaItemRef> all;
                if (!schema.TryGetValue(type, out all))
                {
                    all = new List <DBSchemaItemRef>();
                    schema.Add(type, all);
                }
                all.Add(item);
            }

            foreach (Dictionary <DBSchemaTypes, List <DBSchemaItemRef> > package in byschema.Values)
            {
                foreach (List <DBSchemaItemRef> value in package.Values)
                {
                    value.Sort(delegate(DBSchemaItemRef one, DBSchemaItemRef two) { return(one.Name.CompareTo(two.Name)); });
                }
            }
        }
        protected virtual void FillNotSupported(TypedOperationCollection all)
        {
            Array values = Enum.GetValues(typeof(DBSchemaOperation));

            //We don't support databases
            DBSchemaTypes type = DBSchemaTypes.Database;

            foreach (DBSchemaOperation op in values)
            {
                all.Add(type, op);
            }

            //We don't support users
            type = DBSchemaTypes.User;
            foreach (DBSchemaOperation op in values)
            {
                all.Add(type, op);
            }

            //we don't support groups or roles
            type = DBSchemaTypes.Group;
            foreach (DBSchemaOperation op in values)
            {
                all.Add(type, op);
            }

            //can't create functions
            type = DBSchemaTypes.Function;
            foreach (DBSchemaOperation op in values)
            {
                if (op != DBSchemaOperation.Exec)
                {
                    all.Add(type, op);
                }
            }

            //can't create sprocs
            type = DBSchemaTypes.StoredProcedure;
            foreach (DBSchemaOperation op in values)
            {
                if (op != DBSchemaOperation.Exec)
                {
                    all.Add(type, op);
                }
            }
        }
        public override void EndCreate(DBSchemaTypes type, bool checknotexists)
        {
            if (type == DBSchemaTypes.StoredProcedure)
            {
                throw new NotSupportedException(string.Format(Errors.DatabaseEngineDoesntSupportType, type));
            }

            if (type != DBSchemaTypes.ForeignKey)
            {
                //Special case where the CREATE VIEW .. AS cannot have parenthese after - causes exception
                if (type == DBSchemaTypes.View)
                {
                    this.IncrementStatementDepth();
                }
            }
            base.EndCreate(type, checknotexists);
        }
        //Drop overrides for the supported syntax - DROP .... IF EXISTS
        //Rather than the default IF EXISTS (SELECT FROM INFO SCHEMA)

        public override void BeginDropStatement(DBSchemaTypes type, string owner, string name, bool checkExists)
        {
            if (checkExists)
            {
                if (type == DBSchemaTypes.Index)
                {
                    throw new ArgumentOutOfRangeException("checkExists", string.Format(Errors.DBDoesntSupportIfExistsForThisType, "MySQL", type));
                }
            }
            this.BeginDropStatement(type);

            if (checkExists)
            {
                this.WriteCheckExists(type, owner, name);
            }

            this.WriteSourceTable(owner, name, string.Empty);
        }
        public override void BeginDropStatement(DBSchemaTypes type, string owner, string name, bool checkExists)
        {
            if (type == DBSchemaTypes.StoredProcedure)
            {
                throw new NotSupportedException(string.Format(Errors.DatabaseEngineDoesntSupportType, type));
            }

            this.BeginDropStatement(type);

            if (checkExists)
            {
                this.WriteCheckExists(type, owner, name);
            }

            this.WriteSourceTable(owner, name, string.Empty);

            if (type == DBSchemaTypes.Index)
            {
                _droppingIndex = true;
            }
        }
Example #26
0
        /// <summary>
        /// returns the index of the image in the ImageList based upon the schema type
        /// </summary>
        /// <param name="dBSchemaTypes"></param>
        /// <returns></returns>
        private int GetIconForType(DBSchemaTypes dBSchemaTypes)
        {
            int imgIndex;

            switch (dBSchemaTypes)
            {
            case DBSchemaTypes.Table:
                imgIndex = 0;
                break;

            case DBSchemaTypes.View:
                imgIndex = 3;
                break;

            case DBSchemaTypes.StoredProcedure:
                imgIndex = 5;
                break;

            case DBSchemaTypes.Function:
                imgIndex = 4;
                break;

            case DBSchemaTypes.Index:
                imgIndex = 1;
                break;

            case DBSchemaTypes.CommandScripts:
                imgIndex = 6;
                break;

            case DBSchemaTypes.ForeignKey:
                imgIndex = 2;
                break;

            default:
                imgIndex = -1;
                break;
            }
            return(imgIndex);
        }
        public override void BeginCreate(DBSchemaTypes type, string owner, string name, string options, bool checknotexists)
        {
            if (checknotexists)
            {
                if (type == DBSchemaTypes.Index || type == DBSchemaTypes.View)
                {
                    throw new ArgumentOutOfRangeException("checknotexisits", string.Format(Errors.DBDoesntSupportIfExistsForThisType, "MySQL", type));
                }
            }

            bool isconstraint = IsConstraintType(type);

            if (isconstraint)
            {
                if (!string.IsNullOrEmpty(name))
                {
                    this.WriteRawSQLString("CONSTRAINT ");
                    this.BeginIdentifier();
                    this.WriteObjectName(name);
                    this.EndIdentifier();
                    this.WriteSpace();
                }
            }

            this.BeginCreate(type, options);

            if (checknotexists)
            {
                this.WriteCheckNotExists(type, owner, name);
            }

            if (!this.IsConstraintType(type))
            {
                this.WriteSourceTable(owner, name, string.Empty);
            }
        }
Example #28
0
        //
        // public methods
        //

        #region public bool CheckSupports(DBSchemaTypes schema)

        /// <summary>
        /// Returns true if the Database supports the required schema type
        /// </summary>
        /// <param name="schema">The schema type to check (can be multiple)</param>
        /// <returns>True if the schema type is supported</returns>
        public bool CheckSupports(DBSchemaTypes schema)
        {
            return((this.SupportedSchemas & schema) > 0);
        }
 public override void EndCheckNotExists(DBSchemaTypes type, string owner, string name)
 {
 }
 private void WriteCheckNotExists(DBSchemaTypes type, string owner, string name)
 {
     this.WriteRawSQLString(" IF NOT EXISTS ");
 }