void GenParam(object data, MetaProperty prop, Expression cmdExpr, List <Expression> codes, List <ParameterExpression> locals)
{
var fname = DbTrait.GetFieldname(prop);
var paramExpr = Expression.Parameter(typeof(DbParameter), fname);
locals.Add(paramExpr);
codes.Add(Expression.Assign(paramExpr, Expression.Call(cmdExpr, CreateParameterMethodInfo)));
codes.Add(Expression.Assign(Expression.PropertyOrField(paramExpr, "ParameterName"), Expression.Constant("@" + fname)));
DbType dbType = DbType.String;
this.Trait.DataTypeMaps.TryGetValue(prop.NonullableType.GUID, out dbType);
codes.Add(Expression.Assign(Expression.PropertyOrField(paramExpr, "DbType"), Expression.Constant(dbType)));
var value = prop.GetValue(data);
Expression valueExpr = null;
if (prop.Nullable)
{
int?x;
valueExpr = Expression.Condition(
Expression.PropertyOrField(Expression.Constant(value), "HasValue")
, Expression.PropertyOrField(Expression.Constant(value), "Value")
, Expression.Constant(prop.DefaultValue)
);
}
else
{
valueExpr = Expression.Constant(prop.PropertyType.IsClass?value.ToString():value);
}
codes.Add(Expression.Assign(Expression.PropertyOrField(paramExpr, "Value"), valueExpr));
//DbParameter par;
//par.Value
}
public string CreateTableSql(EntityModel cls, string prefix = null)
{
var sb = new StringBuilder("CREATE TABLE ");
sb.Append(this.Trait.MakeSqlTablename(cls, prefix));
sb.Append("(\n");
bool hasId = false;
bool hasFields = false;
foreach (EntityProperty prop in cls)
{
//Name
if (prop.GetAttribute <NotFieldAttribute>() != null)
{
continue;
}
var fieldName = DbTrait.GetFieldname(prop);
var sqlFieldname = this.Trait.MakeSqlFieldname(fieldName);
if (fieldName == null)
{
continue;
}
if (hasFields)
{
sb.Append("\t,");
}
else
{
sb.Append("\t"); hasFields = true;
}
sb.Append(sqlFieldname);
sb.Append(" ").Append(this.Trait.GetSqlFieldTypeAndPrecision(prop));
if (prop.Nullable || prop.PropertyType.IsClass)
{
sb.Append(" NULL");
}
else
{
sb.Append(" NOT NULL");
}
if (fieldName == "Id" || fieldName == "id" || fieldName == "ID" || fieldName == cls.Name + "Id" || fieldName == cls.Name + "ID")
{
if (!hasId)
{
sb.Append(" PRIMARY KEY");
}
hasId = true;
}
sb.Append("\n");
}
sb.Append(")");
return(sb.ToString());
}
string GenSql(object entity)
{
var sql_fields = "";
var sql_values = "";
foreach (var prop in this.Model.Members)
{
if (prop.GetAttribute <NotFieldAttribute>() != null)
{
continue;
}
var fname = this.Trait.MakeSqlFieldname(prop);
if (fname == null)
{
continue;
}
if (sql_fields != string.Empty)
{
sql_fields += ",";
}
if (sql_values != string.Empty)
{
sql_values += ",";
}
sql_fields += fname;
switch (this.Trait.ParametricKind)
{
case SqlParametricKinds.At:
sql_values += "@" + fname; break;
case SqlParametricKinds.Question:
sql_values += "?"; break;
default:
var hasValue = prop.HasValue(entity);
if (!hasValue)
{
if (prop.Nullable)
{
sql_values += "NULL";
}
else
{
sql_values += prop.DefaultValue.ToString();
}
}
else
{
var val = prop.EnsureValue(entity);
if (val == null)
{
sql_values += "''";
}
sql_values += DbTrait.SqlValue(val.ToString());
}
break;
}
}
return("(" + sql_fields + ") VALUES(" + sql_values + ")");
}
string GenSql(object entity)
{
var sql_fields = "";
var sql_values = "";
foreach (var pair in this.Sql.AllowedProps)
{
var fname = this.Sql.DbTrait.SqlFieldname(pair.Key);
var prop = pair.Value;
if (fname == null)
{
continue;
}
if (sql_fields != string.Empty)
{
sql_fields += ",";
}
if (sql_values != string.Empty)
{
sql_values += ",";
}
sql_fields += fname;
switch (this.Sql.DbTrait.ParametricKind)
{
case SqlParametricKinds.At:
sql_values += "@" + fname; break;
case SqlParametricKinds.Question:
sql_values += "?"; break;
default:
var nullable = prop.Nullable;
var fieldAttr = prop.GetAttribute <DbFieldAttribute>();
if (fieldAttr != null && fieldAttr.IsNullable)
{
nullable = true;
}
var hasValue = prop.HasValue(entity);
if (!hasValue)
{
if (nullable)
{
sql_values += "NULL";
}
else
{
sql_values += DbTrait.SqlValue(prop.DefaultValue, false, prop.DefaultValue) ?? "''";
}
}
else
{
var val = prop.EnsureValue(entity);
if (val == null)
{
sql_values += "''";
}
sql_values += DbTrait.SqlValue(val.ToString());
}
break;
}
}
return("(" + sql_fields + ") VALUES(" + sql_values + ")");
}
Delegate GenFill(bool retTyped = false)
{
var readerExpr = Expression.Parameter(typeof(IDataReader), "reader");
var indexExpr = Expression.Parameter(typeof(int), "index");
var valObjExpr = Expression.Parameter(typeof(object), "valObj");
var entityExpr = Expression.Parameter(this.Model.Type, "entity");
int i = 0;
var codes = new List <Expression>();
codes.Add(Expression.Assign(entityExpr, Expression.New(this.Model.Type)));
foreach (var member in this.Model.Members)
{
var fieldname = DbTrait.GetFieldname(member);
if (fieldname == null)
{
continue;
}
//codes.Add();
//if(member.)
var readReaderExpr = Expression.Assign(
valObjExpr,
Expression.Call(readerExpr, DataReaderGetItemMethod, Expression.PostIncrementAssign(indexExpr))
);
codes.Add(readReaderExpr);
Expression convertExpr = null;
if (member.Nullable)
{
var ctorMethod = member.PropertyType.GetConstructors().First(p => p.GetParameters().Length == 1);
convertExpr = Expression.New(ctorMethod,
Expression.Convert(valObjExpr, member.NonullableType)
);
}
else
{
convertExpr = Expression.Convert(valObjExpr, member.NonullableType);
}
var chkDbNullExpr = Expression.IfThen(
Expression.NotEqual(valObjExpr, Expression.Constant(DBNull.Value))
, Expression.Assign(
Expression.PropertyOrField(entityExpr, member.Name)
, convertExpr
)
);
codes.Add(chkDbNullExpr);
}
var retLabel = Expression.Label();
codes.Add(Expression.Return(retLabel, retTyped ? entityExpr : (Expression)Expression.Convert(entityExpr, typeof(object))));
codes.Add(Expression.Label(retLabel));
var block = Expression.Block(new List <ParameterExpression> {
valObjExpr, entityExpr
}, codes);
//IDataReader rs;rs[]
var lamda = Expression.Lambda(block, readerExpr);
return(lamda.Compile());
}
