Exemple #1
0
        /// <summary>
        /// Returns a command appropriate for modifying a column in MYSQL
        /// </summary>
        /// <param name="type">The type (Table info)</param>
        /// <param name="dfi">The field to edit</param>
        /// <param name="targetFieldType">the new column type</param>
        /// <returns></returns>
        public override IEnumerable <IDbCommand> GetModifyColumnCommand(DatabaseTypeInfo type, DataFieldInfo dfi, string targetFieldType)
        {
            MySqlCommand cmd = new MySqlCommand();

            cmd.CommandText = string.Format(_ModifyColumn, ResolveTableName(type, false), dfi.EscapedFieldName, targetFieldType);
            yield return(cmd);
        }
Exemple #2
0
        /// <summary>
        /// Returns a command for removing a column from a table
        /// </summary>
        /// <param name="type">The type to remove the column from</param>
        /// <param name="dfi">The column to remove</param>
        /// <returns></returns>
        public override IDbCommand GetRemoveColumnCommand(DatabaseTypeInfo type, DataFieldInfo dfi)
        {
            SqlCommand scmd = new SqlCommand();

            scmd.CommandText = string.Format("ALTER TABLE {0}.{1} DROP COLUMN [{2}]", type.Schema, type.TableName, dfi.FieldName);
            return(scmd);
        }
Exemple #3
0
        /// <summary>
        /// Returns a command for creating a new table
        /// </summary>
        /// <param name="ti">The type to create a table for</param>
        /// <returns></returns>
        public override IEnumerable <IDbCommand> GetAddTableCommand(DatabaseTypeInfo ti)
        {
            List <IDbCommand> toReturn = new List <IDbCommand>();
            StringBuilder     sb       = new StringBuilder();
            StringBuilder     pFields  = new StringBuilder();
            SqlCommand        cmd      = new SqlCommand();

            sb.AppendFormat("CREATE TABLE {0}.{1} (", ti.Schema, ti.TableName);
            for (int i = 0; i < ti.DataFields.Count; i++)
            {
                DataFieldInfo dfi = ti.DataFields[i];
                if (i > 0)
                {
                    sb.Append(",");
                }

                if (dfi.PrimaryKey)
                {
                    if (pFields.Length > 0)
                    {
                        pFields.Append(",");
                    }
                    pFields.Append(dfi.FieldName);

                    if (dfi.PropertyType == typeof(int) && ti.PrimaryKeys.Count == 1)
                    {
                        sb.AppendFormat("{0} {1} NOT NULL IDENTITY(1,1) ", dfi.EscapedFieldName, TranslateTypeToSql(dfi));
                    }
                    else
                    {
                        sb.AppendFormat("{0} {1} NOT NULL ", dfi.EscapedFieldName, TranslateTypeToSql(dfi));
                    }
                }
                else
                {
                    sb.AppendFormat("{0} {1} NULL ", dfi.EscapedFieldName, TranslateTypeToSql(dfi));
                }

                if (dfi.PrimaryKeyType != null)
                {
                    SqlCommand fk = new SqlCommand();
                    fk.CommandText = GetForeignKeySql(dfi, ti, DataStore.TypeInformationParser.GetTypeInfo(dfi.PrimaryKeyType));
                    toReturn.Add(fk);
                }
            }
            sb.Append(") ON [PRIMARY];");

            if (pFields.Length > 0)
            {
                SqlCommand pKey = new SqlCommand();
                pKey.CommandText = string.Format("ALTER TABLE {0}.{1} ADD CONSTRAINT PK_{3}_{4} PRIMARY KEY CLUSTERED ({2})",
                                                 ti.Schema, ti.TableName, pFields.ToString(), ti.UnEscapedSchema, ti.UnescapedTableName);

                toReturn.Insert(0, pKey);
            }

            cmd.CommandText = sb.ToString();
            toReturn.Insert(0, cmd);
            return(toReturn);
        }
Exemple #4
0
        /// <summary>
        /// Gets the name of the column.
        /// </summary>
        /// <param name="memberInfo">The member info.</param>
        /// <returns></returns>
        public string GetColumnName(MemberInfo memberInfo)
        {
            DatabaseTypeInfo ti    = _dstore.Connection.CommandGenerator.TypeParser.GetTypeInfo(memberInfo.DeclaringType);
            DataFieldInfo    field = ti.DataFields.Where(R => R.PropertyName.Equals(memberInfo.Name, StringComparison.InvariantCultureIgnoreCase)).FirstOrDefault();

            return(field != null ? field.EscapedFieldName : "");
        }
Exemple #5
0
        /// <summary>
        /// Returns a command for removing a column from a table
        /// </summary>
        /// <param name="type">The type to remove the column from</param>
        /// <param name="dfi">The column to remove</param>
        /// <returns></returns>
        public override IDbCommand GetRemoveColumnCommand(DatabaseTypeInfo type, DataFieldInfo dfi)
        {
            NpgsqlCommand command = new NpgsqlCommand();

            command.CommandText = string.Format("ALTER TABLE {0} DROP COLUMN {1};", ResolveTableName(type, false), dfi.FieldName);
            return(command);
        }
Exemple #6
0
        /// <summary>
        /// Gets a lot of information from a type
        /// </summary>
        /// <param name="type">The type to parse</param>
        /// <param name="bypassValidate">If true, type will not validate against datastore</param>
        /// <returns></returns>
        public virtual DatabaseTypeInfo GetTypeInfo(Type type, bool bypassValidate = false)
        {
            DatabaseTypeInfo toReturn = Cache.GetObject(type);

            if (toReturn == null)
            {
                lock (Cache)
                {
                    toReturn = Cache.GetObject(type);

                    if (toReturn == null)
                    {
                        toReturn = new DatabaseTypeInfo(type);

                        if (!type.IsSystemType())
                        {
                            ParseBypass(type, toReturn);
                            ParseDataInfo(type, toReturn);
                        }

                        StoreTypeInfo(bypassValidate, type, toReturn);
                    }
                }
            }

            return(toReturn);
        }
Exemple #7
0
        /// <summary>
        /// Determines whether the specified entity is mapped.
        /// </summary>
        /// <param name="entity">The entity.</param>
        /// <param name="member">The member.</param>
        /// <returns>
        ///   <c>true</c> if the specified entity is mapped; otherwise, <c>false</c>.
        /// </returns>
        public bool IsMapped(MappingEntity entity, MemberInfo member)
        {
            DatabaseTypeInfo ti    = _dstore.Connection.CommandGenerator.TypeParser.GetTypeInfo(entity.EntityType);
            DataFieldInfo    field = ti.DataFields.Where(R => R.PropertyName.Equals(member.Name, StringComparison.InvariantCultureIgnoreCase)).FirstOrDefault();

            return(field != null && field.LoadField);
        }
Exemple #8
0
        public virtual void Test_Can_Parse_Object()
        {
            DatabaseTypeInfo ti = dstore.Connection.CommandGenerator.TypeParser.GetTypeInfo(typeof(TestItem));

            Assert.IsNotNull(ti);

            Assert.IsNotNull(ti.DataFields);
            foreach (DataFieldInfo dfi in ti.DataFields)
            {
                Assert.IsTrue(dfi.LoadField);
                if (dfi.PrimaryKey)
                {
                    Assert.IsFalse(dfi.SetOnInsert);
                }
                else
                {
                    Assert.IsTrue(dfi.SetOnInsert);
                }
                Assert.IsTrue(!string.IsNullOrEmpty(dfi.FieldName));
                Assert.IsNotNull(dfi.Getter);
                Assert.IsNotNull(dfi.Setter);
            }


            Assert.IsFalse(ti.BypassValidation);
            Assert.IsNotNull(ti.AdditionalInit);
            Assert.IsTrue(ti.AdditionalInit.Count == 0);
        }
Exemple #9
0
        public virtual void Test_Can_parse_ByPass()
        {
            DatabaseTypeInfo ti = dstore.Connection.CommandGenerator.TypeParser.GetTypeInfo(typeof(TestItemBypassValidation));

            Assert.IsNotNull(ti);
            Assert.IsTrue(ti.BypassValidation);
        }
Exemple #10
0
        /// <summary>
        /// Returns a list of columns comma separated, appropriate for select from
        /// </summary>
        /// <param name="type">The type</param>
        /// <returns></returns>
        public virtual string GetSelectList(Type type)
        {
            DatabaseTypeInfo ti = TypeParser.GetTypeInfo(type);

            if (ti.SelectString == null)
            {
                StringBuilder sb = new StringBuilder();

                foreach (DataFieldInfo dfi in ti.DataFields)
                {
                    if (!dfi.LoadField)
                    {
                        continue;
                    }
                    if (sb.Length > 0)
                    {
                        sb.Append(",");
                    }
                    sb.Append(ResolveFieldName(dfi.PropertyName, type));
                }

                ti.SelectString = sb.ToString();
            }

            return(ti.SelectString);
        }
Exemple #11
0
        /// <summary>
        /// Gets a lot of information from a type
        /// </summary>
        /// <param name="type">The type to parse</param>
        /// <param name="bypassValidate">If true, type will not validate against datastore</param>
        /// <returns></returns>
        public virtual DatabaseTypeInfo GetTypeInfo(Type type, bool bypassValidate = false)
        {
            DatabaseTypeInfo toReturn = _cache.GetObject(type);

            if (toReturn == null)
            {
                if (toReturn == null)
                {
                    toReturn           = new DatabaseTypeInfo(type);
                    toReturn.IsDynamic = type.IsDynamic();

                    if (!type.IsSystemType())
                    {
                        ParseBypass(type, toReturn);
                        ParseDataInfo(type, toReturn);
                    }

                    lock (this)
                    {
                        if (_cache.StoreObject(type, toReturn))
                        {
                            OnTypeParsed?.Invoke(this, new TypeParsedEventArgs(toReturn, type, bypassValidate));
                        }
                        else
                        {
                            toReturn = _cache.GetObject(type);
                        }
                    }
                }
            }

            return(toReturn);
        }
Exemple #12
0
        /// <summary>
        /// Generates a select for a single object
        /// </summary>
        /// <param name="item">The item to load (primary key needs to be set)</param>
        /// <returns></returns>
        public virtual IDbCommand GetSelectCommand(object item)
        {
            Type             t   = item.GetType();
            DatabaseTypeInfo ti  = TypeParser.GetTypeInfo(t);
            IDbCommand       cmd = _connection.GetCommand();

            StringBuilder sb = new StringBuilder();

            sb.AppendFormat("SELECT {0} FROM {1} WHERE ", GetSelectList(t), ResolveTableName(ti));

            for (int i = 0; i < ti.PrimaryKeys.Count; i++)
            {
                DataFieldInfo dfi   = ti.PrimaryKeys[i];
                object        value = dfi.Getter(item);

                if (value != null)
                {
                    if (i > 0)
                    {
                        sb.Append(" AND ");
                    }
                    string pName = GetParameterName(cmd);
                    sb.Append(string.Concat(dfi.EscapedFieldName, "=", pName));
                    cmd.Parameters.Add(_connection.GetParameter(pName, value));
                }
            }

            cmd.CommandText = sb.ToString();
            return(cmd);
        }
Exemple #13
0
        public override void Test_Can_Get_Tables()
        {
            DatabaseTypeInfo       ti     = dstore.Connection.CommandGenerator.TypeParser.GetTypeInfo(typeof(TestItemTwoKeys));
            IEnumerable <DBObject> tables = dstore.SchemaValidator.TableValidator.GetObjects();

            Assert.IsTrue(tables.Count() > 0);
            foreach (DBObject t in tables)
            {
                if (t.Name.StartsWith("sqlite"))
                {
                    continue;
                }
                Assert.IsTrue(t != null);
                Assert.IsTrue(t.Name != "");
                Assert.IsTrue(t.Schema != "");
                Assert.IsNotNull(t.Columns);
                Assert.IsTrue(t.Columns.Count > 0);

                foreach (Column c in t.Columns)
                {
                    Assert.IsTrue(c != null);
                    Assert.IsTrue(c.Name != "");
                }
            }
        }
Exemple #14
0
 /// <summary>
 /// Checks for deleted columns.
 /// </summary>
 /// <param name="typeInfo">The type info.</param>
 /// <param name="t">The t.</param>
 /// <param name="valid">The valid.</param>
 /// <returns></returns>
 protected virtual bool CheckForDeletedColumns(DatabaseTypeInfo typeInfo, DBObject t, List <Column> valid)
 {
     if (CanRemoveColumns)
     {
         bool dirty = false;
         if (valid.Count != t.Columns.Count)
         {
             dirty = true;
             foreach (Column c in t.Columns)
             {
                 Column found = valid.Where(R => R.Name.Equals(c.Name, StringComparison.InvariantCultureIgnoreCase)).FirstOrDefault();
                 if (found == null)
                 {
                     RemoveColumn(new DataFieldInfo()
                     {
                         FieldName = c.Name
                     }, typeInfo);
                 }
             }
         }
         return(dirty);
     }
     else
     {
         return(false);
     }
 }
Exemple #15
0
        /// <summary>
        /// Parses data field information from a type
        /// </summary>
        /// <param name="type">The type to parse</param>
        /// <param name="toAdd">What to add the data to</param>
        protected void ParseDataFields(Type type, DatabaseTypeInfo toAdd)
        {
            toAdd.DataFields = new List <DataFieldInfo>();
            PropertyInfo[] properties = type.GetProperties(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy | BindingFlags.Public);

            foreach (PropertyInfo pi in properties)
            {
                DataFieldAttribute    dField       = pi.GetCustomAttributes(typeof(DataFieldAttribute), true).FirstOrDefault() as DataFieldAttribute;
                IgnoredFieldAttribute ignoredField = pi.GetCustomAttributes(typeof(IgnoredFieldAttribute), true).FirstOrDefault() as IgnoredFieldAttribute;

                if (ignoredField == null)
                {
                    DataFieldInfo dfi = new DataFieldInfo();
                    dfi.PropertyType = pi.PropertyType;

                    ParseWithNoDefaults(dfi, dField);
                    ParseFieldName(dfi, dField, pi);
                    ParsePrimaryFieldType(dfi, pi);
                    ParseSetOnInsert(dfi, dField);
                    ParseLoad(dfi, dField);
                    ParsePropertyInfo(type, dfi, pi);
                    toAdd.DataFields.Add(dfi);
                }
            }
        }
        public override void Read(Vault vault, BinaryReader br)
        {
            br.ReadUInt32();               // mNumClasses
            br.ReadUInt32();               // padding
            br.ReadUInt32();               // mDefaultDataSize
            _numTypes  = br.ReadUInt32();  // mNumTypes
            _typeNames = br.ReadPointer(); // mTypenames
            //br.ReadUInt32();
            //br.ReadUInt32();
            //_numTypes = br.ReadUInt32();
            ////br.ReadUInt32();
            //_typeNames = br./*ReadPointer*/ReadInt32(); // Pointer

            if (_typeNames == 0)
            {
                throw new InvalidDataException("NULL pointer to mTypeNames is no good!");
            }

            for (var i = 0; i < _numTypes; i++)
            {
                var typeInfo = new DatabaseTypeInfo {
                    Size = br.ReadUInt32()
                };
                vault.Database.Types.Add(typeInfo);
            }
        }
Exemple #17
0
        /// <summary>
        /// Determines the table name to use on the data store
        /// </summary>
        /// <param name="type">The type</param>
        /// <param name="toAdd">What to add the data to</param>
        protected void ParseTableName(Type type, DatabaseTypeInfo toAdd)
        {
            TableNameAttribute tName = type.GetCustomAttributes(typeof(TableNameAttribute), true).FirstOrDefault() as TableNameAttribute;

            if (tName != null)
            {
                toAdd.UnescapedTableName = tName.TableName;
                toAdd.UnEscapedSchema    = tName.Schema;
            }

            if (string.IsNullOrEmpty(toAdd.UnEscapedSchema))
            {
                toAdd.UnEscapedSchema = _connection.Connection.DefaultSchema;
            }

            if (string.IsNullOrEmpty(toAdd.UnescapedTableName))
            {
                toAdd.UnescapedTableName = GenTableName(type);
            }

            //escape table name
            toAdd.TableName = string.Concat(_connection.Connection.LeftEscapeCharacter, toAdd.UnescapedTableName, _connection.Connection.RightEscapeCharacter);

            if (!string.IsNullOrEmpty(toAdd.UnEscapedSchema))
            {
                toAdd.Schema = string.Concat(_connection.Connection.LeftEscapeCharacter, toAdd.UnEscapedSchema, _connection.Connection.RightEscapeCharacter);
            }
        }
Exemple #18
0
 /// <summary>
 /// Fires the created event
 /// </summary>
 /// <param name="ti">The ti.</param>
 protected void FireCreated(DatabaseTypeInfo ti)
 {
     if (OnObjectCreated != null)
     {
         OnObjectCreated(this, new ObjectCreatedEventArgs(ti));
     }
 }
Exemple #19
0
        private void ProcessBulkInsert(IList list, Type t, DatabaseTypeInfo ti, DBObject table)
        {
            DataTable dt = new DataTable();

            AddColumnsToTable(dt, ti, table);

            foreach (object record in list)
            {
                DataRow dr = dt.NewRow();
                foreach (DataFieldInfo dfi in ti.DataFields)
                {
                    object item = dfi.Getter(record);
                    if (item == null)
                    {
                        dr[dfi.FieldName] = DBNull.Value;
                    }
                    else
                    {
                        dr[dfi.FieldName] = item;
                    }
                }

                dt.Rows.Add(dr);
            }
            WriteToServer(dt, this.CommandGenerator.ResolveTableName(t));
        }
Exemple #20
0
        private object BuildObject(IQueryRow dt, DatabaseTypeInfo ti)
        {
            object toReturn = ObjectBuilder.BuildObject(this, dt, ti);

            FireObjectLoaded(toReturn);
            return(toReturn);
        }
Exemple #21
0
        /// <summary>
        /// Gets the primary key.
        /// </summary>
        /// <param name="entity">The entity.</param>
        /// <param name="instance">The instance.</param>
        /// <returns></returns>
        public object GetPrimaryKey(MappingEntity entity, object instance)
        {
            object           firstKey = null;
            List <object>    keys     = null;
            DatabaseTypeInfo ti       = _dstore.Connection.CommandGenerator.TypeParser.GetTypeInfo(entity.EntityType);

            foreach (DataFieldInfo v in ti.PrimaryKeys)
            {
                if (firstKey == null)
                {
                    firstKey = v.Getter(instance);
                }
                else
                {
                    if (keys == null)
                    {
                        keys = new List <object>();
                        keys.Add(firstKey);
                    }
                    keys.Add(v.Getter(instance));
                }
            }
            if (keys != null)
            {
                return(new CompoundKey(keys.ToArray()));
            }
            return(firstKey);
        }
Exemple #22
0
        /// <summary>
        /// Executes a db command and fills in a list of objects with the result data
        /// </summary>
        /// <typeparam name="ReturnType">The type of object to return</typeparam>
        /// <param name="objectType">The type of object to return.</param>
        /// <param name="command">The command to execute</param>
        /// <returns></returns>
        protected virtual IEnumerable <ReturnType> ExecuteCommandLoadList <ReturnType>(Type objectType, IDbCommand command)
        {
            DatabaseTypeInfo ti = Connection.CommandGenerator.TypeParser.GetTypeInfo(objectType);

            using (IQueryData dt = ExecuteCommands.ExecuteCommandQuery(command, Connection))
            {
                if (dt.QuerySuccessful)
                {
                    foreach (IQueryRow row in dt)
                    {
                        ReturnType toAdd;

                        if (objectType.IsSystemType())
                        {
                            toAdd = (ReturnType)Connection.CLRConverter.ConvertToType(row.GetDataForRowField(0), typeof(ReturnType));
                        }
                        else
                        {
                            toAdd = (ReturnType)BuildObject(row, ti);
                        }

                        yield return(toAdd);
                    }
                }
            }
        }
Exemple #23
0
        /// <summary>
        /// Validates an  existing view.
        /// </summary>
        /// <param name="ti">The ti.</param>
        /// <param name="obj">The obj.</param>
        protected virtual void ValidateExistingView(DatabaseTypeInfo ti, DBObject obj)
        {
            List <string> Missing = new List <string>();

            foreach (DataFieldInfo dfi in ti.DataFields)
            {
                Column c = obj.Columns.Where(R => R.Name.Equals(dfi.FieldName, StringComparison.InvariantCultureIgnoreCase)).FirstOrDefault();
                if (c == null)
                {
                    Missing.Add(dfi.FieldName);
                }
            }

            if (Missing.Count > 0)
            {
                StringBuilder sb = new StringBuilder();
                for (int i = 0; i < Missing.Count; i++)
                {
                    if (i > 0)
                    {
                        sb.Append(",");
                    }
                    sb.AppendFormat(" {0}", Missing[i]);
                }

                throw new DataStoreException(string.Format("The view {0} is missing the following columns {1}", ti.TableName, sb.ToString()));
            }
        }
Exemple #24
0
        /// <summary>
        /// Creates an object and inits the primary key field
        /// </summary>
        /// <param name="item">The item.</param>
        /// <param name="key">The key.</param>
        /// <param name="ti">The type info.</param>
        /// <returns></returns>
        protected static object CreateObjectSetKey(Type item, object key, DatabaseTypeInfo ti)
        {
            object toReturn = item.GetConstructor(new Type[] { }).Invoke(new object[] { });

            ti.PrimaryKeys[0].Setter(toReturn, key);
            return(toReturn);
        }
Exemple #25
0
        protected void RetrieveDataStore()
        {
            _dstore = GetDataStore().GetNewInstance();

            _tables = new ModifyTableValidator(_dstore);
            _tables.CanAddColumns    = true;
            _tables.CanRemoveColumns = true;
            _tables.CanUpdateColumns = true;


            _views = _dstore.SchemaValidator.ViewValidator;
            if (_views == null)
            {
                _views = new ViewValidator(_dstore);
            }

            DatabaseTypeInfo ti = _dstore.TypeInformationParser.GetTypeInfo(typeof(RanMigration));

            if (_dstore.SchemaValidator.TableValidator == null || !_dstore.SchemaValidator.TableValidator.CanAddColumns)
            {
                _tables.ValidateObject(ti);
            }

            _dstore.SchemaValidator = new DoesNothingValidator();
        }
Exemple #26
0
 private void CheckForMultipleKeys(DatabaseTypeInfo toAdd)
 {
     if (toAdd.PrimaryKeys.Count > 1)
     {
         toAdd.PrimaryKeys.ForEach(R => R.SetOnInsert = true);
     }
 }
Exemple #27
0
        /// <summary>
        /// Gets a command for changing a column type
        /// </summary>
        /// <param name="type">The type</param>
        /// <param name="dfi">The field</param>
        /// <param name="targetFieldType">The new column type</param>
        /// <returns></returns>
        public override IEnumerable <IDbCommand> GetModifyColumnCommand(DatabaseTypeInfo type, DataFieldInfo dfi, string targetFieldType)
        {
            SqlCommand cmd = new SqlCommand();

            cmd.CommandText = string.Format("ALTER TABLE {0} ALTER COLUMN [{1}] {2}", ResolveTableName(type), dfi.FieldName, targetFieldType);
            yield return(cmd);
        }
Exemple #28
0
        /// <summary>
        /// Parses the additional init and OnTableCreate attributes
        /// </summary>
        /// <param name="type">The type to parse</param>
        /// <param name="toAdd">What to add the data to</param>
        protected void ParseFunctionAttributes(Type type, DatabaseTypeInfo toAdd)
        {
            toAdd.AdditionalInit = new List <AdditionalInitFunction>();
            toAdd.OnTableCreate  = new List <AdditionalInitFunction>();

            MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.Static);
            foreach (MethodInfo mi in methods)
            {
                QueryPredicateAttribute qpred = mi.GetCustomAttributes(typeof(QueryPredicateAttribute), true).FirstOrDefault() as QueryPredicateAttribute;
                if (qpred != null)
                {
                    toAdd.QueryPredicate = new QueryPredicateFunction(mi);
                }

                AdditionalInitAttribute aAtt = mi.GetCustomAttributes(typeof(AdditionalInitAttribute), true).FirstOrDefault() as AdditionalInitAttribute;
                if (aAtt != null)
                {
                    toAdd.AdditionalInit.Add(new AdditionalInitFunction(mi));
                }

                OnTableCreateAttribute tcAtt = mi.GetCustomAttributes(typeof(OnTableCreateAttribute), true).FirstOrDefault() as OnTableCreateAttribute;
                if (tcAtt != null)
                {
                    toAdd.OnTableCreate.Add(new AdditionalInitFunction(mi));
                }
            }
        }
Exemple #29
0
        private async Task <object> BuildObjectAsync(IQueryRow dt, DatabaseTypeInfo ti)
        {
            object toReturn = await Task.Run(() => ObjectBuilder.BuildObject(_dstore, dt, ti));

            FireObjectLoaded(toReturn);
            return(toReturn);
        }
Exemple #30
0
        /// <summary>
        /// Returns a command for removing a column from a table
        /// </summary>
        /// <param name="type">The type to remove the column from</param>
        /// <param name="dfi">The column to remove</param>
        /// <returns></returns>
        public override IDbCommand GetRemoveColumnCommand(DatabaseTypeInfo type, DataFieldInfo dfi)
        {
            SqlCeCommand scmd = new SqlCeCommand();

            scmd.CommandText = string.Format("ALTER TABLE {0} DROP COLUMN [{1}]", ResolveTableName(type), dfi.FieldName);
            return(scmd);
        }