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());
}
