private TranslateResult TranslateValues(object instance, Type type, List <Parameter> parameters)
{
TableSchema tableSchema = TableSchemaResolver.GetTableSchema(type);
for (int i = 0, count = tableSchema.FieldsSchema.Count; i < count; i++)
{
var field = tableSchema.FieldsSchema[i];
object value = ExpressionFunc.GetPropertyValue(instance, type, field.PropertyInfo);
if (value == null && field.PropertyInfo.PropertyType.Name == "String")
{
value = "";
}
if (parameters == null)
{
clauseBuilder.AppendClause(parameterBuilder.GenerateParameterName(), value);
}
else
{
clauseBuilder.AppendClause(parameters[i].Name, value);
}
}
return(new TranslateResult
{
CommandText = clauseBuilder.GetExpressionText(","), // INSERT ... VALUES(@value1,@value2,@value3,...)
Parameters = clauseBuilder.GetExpressionParameters(),
});
}
private void InsertRecordToCache(TTable record)
{
Func <TTable, TTable> cloneFunc = ExpressionFunc.PrimaryKeyClone <TTable>();
this._recordsCache.Add(new RecordCache <TTable>
{
recordOut = record,
recordCache = cloneFunc(record)
});
}
internal List <RecordCache <TTable> > Excute <TTable>(string sqlCommand, List <Parameter> parameters, List <bool> fieldsUsable) where TTable : new()
{
dbError = new DbError();
if (string.IsNullOrEmpty(connection.ConnectionString))
{
return(null);
}
Func <DbDataReader, TTable> readRowFunc = ExpressionFunc.GetReader <TTable>(fieldsUsable);
Func <TTable, TTable> cloneFunc = ExpressionFunc.PrimaryKeyClone <TTable>();
if (readRowFunc == null || cloneFunc == null)
{
return(null);
}
if (connection.State != ConnectionState.Open)
{
connection.Open();
}
try
{
// Create the command and open the connection
var command = connection.CreateCommand();
command.CommandText = sqlCommand;
command.CommandTimeout = 15;
command.CommandType = CommandType.Text;
if (parameters != null)
{
for (int index = 0; index < parameters.Count; index++)
{
var dbParameter = command.CreateParameter();
dbParameter.ParameterName = parameters[index].Name;
dbParameter.Value = parameters[index].Value;
command.Parameters.Add(dbParameter);
}
}
// Create the DataReader to retrieve data
using (var dr = command.ExecuteReader(CommandBehavior.CloseConnection))
{
return(ReadRecords <TTable>(dr, readRowFunc, cloneFunc));
}
}
catch (Exception e)
{
dbError.Code = ErrorCode.DatabaseException;
dbError.Text = e.Message;
return(null);
}
}
public override void Initialize(MemberInfo member, Type memberValueType)
{
if (this.Attribute.MemberName != null && this.Attribute.MemberName.Length > 0 && this.Attribute.MemberName[0] == '@')
{
var expression = this.Attribute.MemberName.Substring(1);
var emitContext = new EmitContext()
{
IsStatic = member.IsStatic(),
ReturnType = typeof(bool),
Type = member.ReflectedType,
Parameters = new Type[] { member.GetReturnType() },
ParameterNames = new string[] { "value" }
};
var del = ExpressionUtility.ParseExpression(expression, emitContext, out this.memberErrorMessage);
if (emitContext.IsStatic)
{
this.staticValidationExpression = (ExpressionFunc <T, bool>)del;
}
else
{
this.instanceValidationExpression = del;
}
}
else
{
LegacyFindMember(member);
}
this.defaultMessageString = this.Attribute.DefaultMessage ?? "Value is invalid for member '" + member.Name + "'";
this.defaultResultType = this.Attribute.MessageType.ToValidationResultType();
if (this.Attribute.DefaultMessage != null)
{
this.validationMessageHelper = new StringMemberHelper(member.ReflectedType, false, this.Attribute.DefaultMessage);
if (this.validationMessageHelper.ErrorMessage != null)
{
if (this.memberErrorMessage != null)
{
this.memberErrorMessage += "\n\n" + this.validationMessageHelper.ErrorMessage;
}
else
{
this.memberErrorMessage = this.validationMessageHelper.ErrorMessage;
}
this.validationMessageHelper = null;
}
}
}
private TranslateResult TranslateColumnValue(object instance, Type type, List <bool> fieldsUsable, List <Parameter> parameters)
{
bool isFirst = true;
TableSchema tableSchema = TableSchemaResolver.GetTableSchema(type);
for (int i = 0, count = tableSchema.FieldsSchema.Count; i < count; i++)
{
var field = tableSchema.FieldsSchema[i];
if (fieldsUsable[i] && field.IsPrimaryKey == false)
{
object value = ExpressionFunc.GetPropertyValue(instance, type, field.PropertyInfo);
if (value == null && field.PropertyInfo.PropertyType.Name == "String")
{
value = "";
}
if (value == null)
{
throw new NotSupportedException(string.Format("The field '{0}' is not supported", field.FieldName));
}
if (!isFirst)
{
clauseBuilder.AppendClause(",");
}
clauseBuilder.AppendClause(field.FieldName);
clauseBuilder.AppendClause("=");
if (field.IsUpdCount)
{
int iValue = Convert.ToInt32(value);
if (iValue == short.MaxValue)
{
iValue = 1;
}
else
{
iValue++;
}
value = Convert.ChangeType(iValue, field.PropertyInfo.PropertyType);
ExpressionFunc.SetPropertyValue(instance, type, field.PropertyInfo, value);
}
clauseBuilder.AppendClause(parameterBuilder.GenerateParameterName(), value);
isFirst = false;
}
}
return(new TranslateResult
{
CommandText = clauseBuilder.GetExpressionText(), // UPDATE ... column1=@value1,column2=@value2,...
Parameters = clauseBuilder.GetExpressionParameters(),
});
}
private TranslateResult TranslateWhere(object instance, Type type, List <Parameter> parameters)
{
bool isFirst = true;
TableSchema tableSchema = TableSchemaResolver.GetTableSchema(type);
int paramIndex = 0;
for (int i = 0, count = tableSchema.FieldsSchema.Count; i < count; i++)
{
var field = tableSchema.FieldsSchema[i];
if (field.IsPrimaryKey || field.IsUpdCount)
{
object value = ExpressionFunc.GetPropertyValue(instance, type, field.PropertyInfo);
if (value == null)
{
throw new NotSupportedException(string.Format("The field '{0}' is not supported", field.FieldName));
}
if (!isFirst)
{
clauseBuilder.AppendClause(" And ");
}
clauseBuilder.AppendClause(field.FieldName);
clauseBuilder.AppendClause("=");
if (parameters == null)
{
clauseBuilder.AppendClause(parameterBuilder.GenerateParameterName(), value);
}
else
{
clauseBuilder.AppendClause(parameters[paramIndex++].Name, value);
}
isFirst = false;
}
}
return(new TranslateResult
{
CommandText = clauseBuilder.GetExpressionText(), // UPDATE ...Where key_column=some_value And UpdCount=some_value
// DELETE ...Where key_column=some_value And UpdCount=some_value
Parameters = clauseBuilder.GetExpressionParameters(),
});
}
public bool Update(List <TTable> records)
{
if (records == null || records.Count == 0)
{
return(false);
}
Action <TTable, TTable> copyAction = ExpressionFunc.PrimaryKeyCopy <TTable>();
List <List <Parameter> > listParameters = new List <List <Parameter> >();
Tuple <TranslateResult, TranslateResult> resultFirst = null;
Tuple <TranslateResult, TranslateResult> resultNext = null;
for (int i = 0, count = records.Count; i < count; i++)
{
var record = records[i];
if (IsValidRecord(record) == false)
{
return(false);
}
copyAction(record, GetCacheRecord(record));
List <Parameter> parameters = new List <Parameter>();
if (i == 0)
{
resultFirst = PreUpdate(record, null, null);
parameters.AddRange(resultFirst.Item1.Parameters);
parameters.AddRange(resultFirst.Item2.Parameters);
}
else
{
resultNext = PreUpdate(record, resultFirst.Item1.Parameters, resultFirst.Item2.Parameters);
parameters.AddRange(resultNext.Item1.Parameters);
parameters.AddRange(resultNext.Item2.Parameters);
}
listParameters.Add(parameters);
}
_dbSet.BeginTransaction();
if (listParameters.Count == 1)
{
this._dbError = _excuteUpdate.Excute <TTable>(_sqlBuilder.Update(), listParameters[0], _dbSet.Transaction);
}
else
{
this._dbError = _excuteUpdate.ExcuteBatch <TTable>(_sqlBuilder.Update(), listParameters, _dbSet.Transaction);
}
if (this._dbError.Code == ErrorCode.Success)
{
records.ForEach(rec => copyAction(GetCacheRecord(rec), rec));
}
else
{
_dbSet.Cancel();
}
return(this._dbError.Code == ErrorCode.Success);
}
public bool Delete(List <TTable> records)
{
if (records == null || records.Count == 0)
{
return(false);
}
Action <TTable, TTable> copyAction = ExpressionFunc.PrimaryKeyCopy <TTable>();
List <List <Parameter> > listParameters = new List <List <Parameter> >();
TranslateResult resultFirst = null;
TranslateResult resultNext = null;
for (int i = 0, count = records.Count; i < count; i++)
{
var record = records[i];
if (IsValidRecord(record) == false)
{
return(false);
}
copyAction(record, GetCacheRecord(record));
if (i == 0)
{
resultFirst = _translate.Translator(record, typeof(TTable), _fieldsUsable, ClauseType.SaveWhere);
_sqlBuilder.SaveWhere(resultFirst.CommandText);
listParameters.Add(resultFirst.Parameters);
}
else
{
resultNext = _translate.Translator(record, typeof(TTable), _fieldsUsable, ClauseType.SaveWhere, resultFirst.Parameters);
listParameters.Add(resultNext.Parameters);
}
}
TableSchema tableSchema = TableSchemaResolver.GetTableSchema(typeof(TTable));
_sqlBuilder.From(tableSchema.PrimaryTable);
_dbSet.BeginTransaction();
if (listParameters.Count == 1)
{
this._dbError = _excuteUpdate.Excute <TTable>(_sqlBuilder.Delete(), listParameters[0], _dbSet.Transaction);
}
else
{
this._dbError = _excuteUpdate.ExcuteBatch <TTable>(_sqlBuilder.Delete(), listParameters, _dbSet.Transaction);
}
if (this._dbError.Code == ErrorCode.Success)
{
records.ForEach(rec => DeleteRecordFromCache(rec));
}
else
{
_dbSet.Cancel();
}
return(this._dbError.Code == ErrorCode.Success);
}
