public CollectionParamsQueryExpression(DataFieldInfo fieldInfo, QueryCollectionPredicate predicate, IEnumerable values) : base(fieldInfo.TableMapping) { _fieldInfo = fieldInfo; _predicate = predicate; _values = values; }
internal ConditionSumFunction(DataEntityMapping mapping, QueryExpression expression, DataFieldInfo fieldinfo, bool isDistinct) : base(mapping) { _expression = expression; _fieldinfo = fieldinfo; _isDistinct = isDistinct; }
/// <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); }
internal DateDataFieldInfo(DataFieldInfo info, string format) : base(info) { DataFieldMapping fieldMapping = info.DataField; _format = format; }
/// <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); }
/// <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); }
public AggregateDataFieldInfo(DataFieldInfo fieldInfo, string name, bool aggregate) : base(fieldInfo.TableMapping, true, name) { _fieldInfo = fieldInfo; _aggregateName = name; _aggregate = aggregate; }
/// <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); } } }
/// <summary> /// Gets the name of the column. /// </summary> /// <param name="entity">The entity.</param> /// <param name="member">The member.</param> /// <returns></returns> public string GetColumnName(MappingEntity entity, MemberInfo member) { DatabaseTypeInfo ti = _dstore.TypeInformationParser.GetTypeInfo(entity.EntityType); DataFieldInfo field = ti.DataFields.Where(R => R.PropertyName.Equals(member.Name, StringComparison.InvariantCultureIgnoreCase)).FirstOrDefault(); return(field != null ? field.EscapedFieldName : ""); }
/// <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 : ""); }
/// <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); }
/// <summary> /// Returns a command for adding a column to a table /// </summary> /// <param name="type">The type to add the column to</param> /// <param name="dfi">The column to add</param> /// <returns></returns> public override IDbCommand GetAddColumnCommnad(TypeInfo type, DataFieldInfo dfi) { OracleCommand scmd = new OracleCommand(); scmd.CommandText = string.Format("ALTER TABLE {0} add ({1} {2})", ResolveTableName(type, false), dfi.FieldName, TranslateTypeToSql(dfi)); return(scmd); }
public override IDbCommand GetModifyColumnCommand(TypeInfo type, DataFieldInfo dfi, string targetFieldType) { OracleCommand cmd = new OracleCommand(); cmd.CommandText = string.Format("ALTER TABLE {0} ALTER COLUMN [{1}] {2}", ResolveTableName(type), dfi.FieldName, targetFieldType); return(cmd); }
/// <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(TypeInfo type, DataFieldInfo dfi) { OracleCommand scmd = new OracleCommand(); scmd.CommandText = string.Format("ALTER TABLE {0} DROP COLUMN [{1}]", ResolveTableName(type, false), dfi.FieldName); return(scmd); }
/// <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); }
public LightAggregateFieldDataFieldInfo(DataFieldInfo fieldInfo, AggregateType type, bool distinct) : base(fieldInfo.TableMapping) { _baseFieldInfo = fieldInfo; _type = type; _distinct = distinct; }
public BetweenParamsQueryExpression(DataFieldInfo fieldInfo, bool isNot, object fromValue, object toValue) : base(fieldInfo.TableMapping) { _fieldInfo = fieldInfo; _isNot = isNot; _fromValue = fromValue; _toValue = toValue; }
public SingleParamQueryExpression(DataFieldInfo fieldInfo, QueryPredicate predicate, object value, bool isReverse) : base(fieldInfo.TableMapping) { _fieldInfo = fieldInfo; _predicate = predicate; _value = value; _isReverse = isReverse; }
public LightInQueryDataFieldInfo(DataEntityMapping mapping, DataFieldInfo field, DataFieldInfo selectField, QueryExpression expression, bool isTrue) : base(mapping) { _field = field; _selectField = selectField; _expression = expression; _isTrue = isTrue; }
public SubQueryExpression(DataFieldInfo fieldInfo, QueryCollectionPredicate predicate, DataFieldInfo queryFieldInfo, QueryExpression queryExpression) : base(fieldInfo.TableMapping) { _fieldInfo = fieldInfo; _predicate = predicate; _queryFieldInfo = queryFieldInfo; _queryExpression = queryExpression; }
public SubAggregateExpression(AggregateFunction function, QueryCollectionPredicate predicate, DataFieldInfo queryFieldInfo, QueryExpression queryExpression) : base(function.TableMapping) { _function = function; _predicate = predicate; _queryFieldInfo = queryFieldInfo; _queryExpression = queryExpression; }
/// <summary> /// Translates the type to SQL. /// </summary> /// <param name="type">The type.</param> /// <returns></returns> public override string TranslateTypeToSql(DataFieldInfo type) { string toReturn = type.DataFieldType; if (string.IsNullOrEmpty(toReturn)) { if (type.PrimaryKeyType != null) { //use the primary keys field type instead toReturn = TranslateTypeToSql(DataStore.TypeInformationParser.GetTypeInfo(type.PrimaryKeyType).PrimaryKeys.First()); } else { if (type.PropertyType.IsGenericType && type.PropertyType.GetGenericTypeDefinition() == typeof(Nullable <>)) { type.PropertyType = type.PropertyType.GetGenericArguments()[0]; } string toChange = type.PropertyType.Name.ToUpper(); switch (toChange) { case "TIMESPAN": case "CHAR": case "STRING": toReturn = "VARCHAR"; break; case "INT32": case "INT64": toReturn = "INTEGER"; break; case "SINGLE": case "DOUBLE": toReturn = "DOUBLE"; break; case "BYTE[]": toReturn = "BLOB"; break; case "BOOLEAN": toReturn = "BOOL"; break; case "DATETIME": case "DATETIMEOFFSET": toReturn = "DATETIME"; break; default: toChange = "VARCHAR"; break; } } } return(toReturn); }
public CollectionMatchQueryExpression(DataFieldInfo fieldInfo, object value, bool isReverse, bool isMatch, bool isNot) : base(fieldInfo.TableMapping) { _value = value; _isReverse = isReverse; _isMatch = isMatch; _isNot = isNot; _fieldInfo = fieldInfo; }
public DataFieldQueryExpression(DataFieldInfo fieldInfo, QueryPredicate predicate, DataFieldInfo relateFieldInfo, bool isReverse) : base(fieldInfo.TableMapping) { _fieldInfo = fieldInfo; _predicate = predicate; _relateFieldInfo = relateFieldInfo; _isReverse = isReverse; _isSameTable = Object.Equals(fieldInfo.TableMapping, relateFieldInfo.TableMapping); }
private static void SetDefaultValue(object dataItem, DataFieldInfo dfi) { ConstructorInfo ci = dfi.PropertyType.GetConstructors().Where(R => R.GetParameters().Count() == 0).FirstOrDefault(); if (ci != null) { dfi.Setter(dataItem, ci.Invoke(null)); } }
public LightSubQueryDataFieldInfo(DataEntityMapping mapping, DataFieldInfo field, DataFieldInfo selectField, QueryCollectionPredicate predicate, QueryExpression expression) : base(mapping) { _field = field; _selectField = selectField; _predicate = predicate; _expression = expression; }
/// <summary> /// Determines if a field should be loaded /// </summary> /// <param name="dfi">The field to check</param> /// <param name="dField">The data attribute if present, null otherwise</param> protected void ParseLoad(DataFieldInfo dfi, DataFieldAttribute dField) { dfi.LoadField = true; if (dField != null) { dfi.LoadField = dField.LoadField; } }
/// <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) { StringBuilder sb = new StringBuilder(); StringBuilder pFields = new StringBuilder(); StringBuilder contrain = new StringBuilder(); MySqlCommand cmd = new MySqlCommand(); sb.AppendFormat("CREATE TABLE {0} (", ResolveTableName(ti, false)); 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.AppendFormat("{0}", dfi.FieldName); if (dfi.PropertyType == typeof(int) && ti.PrimaryKeys.Count == 1) { sb.AppendFormat("{0} {1} NOT NULL AUTO_INCREMENT ", 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 && StorageEngine == MySql.StorageEngine.InnoDB) { DatabaseTypeInfo pkType = DataStore.TypeInformationParser.GetTypeInfo(dfi.PrimaryKeyType); contrain.AppendFormat(_createFKSQL, ResolveTableName(ti, false), pkType.UnescapedTableName, pkType.PrimaryKeys.First().EscapedFieldName, TranslateFkeyType(dfi.ForeignKeyType), dfi.EscapedFieldName); } } if (pFields.Length > 0) { sb.AppendFormat(",PRIMARY KEY ({0})", pFields.ToString()); } sb.Append(contrain.ToString()); sb.AppendFormat(") ENGINE = {0}", StorageEngine.ToString()); cmd.CommandText = sb.ToString(); yield return(cmd); }
protected override bool EqualsDetail(DataFieldInfo info) { if (base.EqualsDetail(info)) { SubStringDataFieldInfo target = info as SubStringDataFieldInfo; return(this._start == target._start && this._size == target._size); } else { return(false); } }
private string GetForeignKeySql(DataFieldInfo field, DatabaseTypeInfo targetTable, DatabaseTypeInfo pKeyTable) { StringBuilder sb = new StringBuilder("ALTER TABLE "); sb.AppendFormat("{0}.{1} ", targetTable.Schema, targetTable.TableName); sb.AppendFormat("ADD CONSTRAINT FK_{0}_{1}_{2} ", targetTable.UnEscapedSchema, targetTable.UnescapedTableName, field.FieldName); sb.AppendFormat("FOREIGN KEY({0}) ", field.EscapedFieldName); sb.AppendFormat("REFERENCES {0}.{1} ({2}) ", pKeyTable.Schema, pKeyTable.TableName, pKeyTable.PrimaryKeys[0].EscapedFieldName); sb.AppendFormat("ON UPDATE {0} ON DELETE {0};", TranslateFkeyType(field.ForeignKeyType)); return(sb.ToString()); }