/// <summary>
/// 修改一个实例
/// </summary>
/// <typeparam name="T">实体类型</typeparam>
/// <param name="entity">实体</param>
/// <returns>影响行数</returns>
public static int Update <T>(T entity)
{
var type = typeof(T);
var properties = type.GetProperties().Where(p => !GetAttributes(p).OfType <NonFieldAttribute>().Any());
ParameterizedQueryBuilder parms = new ParameterizedQueryBuilder();
StringBuilder strSql = new StringBuilder();
strSql.Append("Update " + type.Name + " set ");
string fields = "";
string primarykey = "";
string primaryvalue = "";
int loop = 0;
foreach (var p in properties)
{
var name = GetFieldname(p);
if (name.IndexOf("OID") == -1)
{
fields += name + "={" + loop + "},";
parms.AppendParameter(p.GetValue(entity, null));
loop++;
}
else
{
primarykey = name;
primaryvalue = p.GetValue(entity, null).ToString();
}
}
strSql.Append(fields.Substring(0, fields.Length - 1) + " where " + primarykey + "=" + primaryvalue);
return(db.T(strSql.ToString(), parms.CreateQuery().ParameterValues).ExecuteNonQuery());
}
/// <summary>
/// 得到Model组成SQL对象
/// </summary>
/// <typeparam name="T">实体类型</typeparam>
/// <param name="entity">实体</param>
/// <returns>Model组成SQL对象</returns>
public static TModel GetInsertTModel <T>(T entity)
{
TModel tmodel = new TModel();
var type = typeof(T);
var properties = type.GetProperties().Where(p => !GetAttributes(p).OfType <NonFieldAttribute>().Any());
ParameterizedQueryBuilder parms = new ParameterizedQueryBuilder();
StringBuilder strSql = new StringBuilder();
strSql.Append("insert into " + type.Name + "(");
string fields = "";
foreach (var p in properties)
{
var name = GetFieldname(p);
if (name.IndexOf("NOID") == -1)
{
fields += name + ",";
parms.AppendParameter(p.GetValue(entity, null));
}
}
strSql.Append(fields.Substring(0, fields.Length - 1) + ") values({...});select @@IDENTITY");
tmodel.SQL = strSql.ToString();
tmodel.ParameterValues = parms.CreateQuery().ParameterValues;
return(tmodel);
}
private static void AddParameters(ParameterizedQueryBuilder builder, object[] parameters, int begin, int end)
{
for (int parameterIndex = begin; parameterIndex < end; parameterIndex++)
{
AddParameter(builder, parameters[parameterIndex]);
builder.AppendText(",");
}
AddParameter(builder, parameters[end]);
}
/// <summary>
/// 串联多个参数化查询对象
/// </summary>
/// <param name="firstQuery">第一个参数化查询对象</param>
/// <param name="otherQueries">要串联的其他参数化查询对象</param>
/// <returns>串联后的参数化查询对象</returns>
public static ParameterizedQuery Concat(this ParameterizedQuery firstQuery, params ParameterizedQuery[] otherQueries)
{
var builder = new ParameterizedQueryBuilder();
firstQuery.AppendTo(builder);
foreach (var query in otherQueries)
{
if (!builder.IsEndWithWhiteSpace() && !query.IsStartWithWhiteSpace() && Db.AddWhiteSpaceOnConcat)
{
builder.Append(' ');
}
query.AppendTo(builder);
}
return(builder.CreateQuery());
}
private static void AddParameter(ParameterizedQueryBuilder builder, object value)
{
var partial = value as IParameterizedQueryPartial;
if (partial == null)
{
var container = value as IDbQueryContainer;
if (container != null)
{
partial = container.Query as IParameterizedQueryPartial;
}
}
if (partial != null)
{
partial.AppendTo(builder);
return;
}
var array = value as Array;
if (array != null)
{
if (array.Length == 0)
{
return;
}
for (int i = 0; i < array.Length - 1; i++)
{
AddParameter(builder, array.GetValue(i));
builder.AppendText(",");
}
AddParameter(builder, array.GetValue(array.Length - 1));
return;
}
builder.AppendParameter(value);
}
/// <summary>
/// 将多个参数化查询串联起来并用指定的字符串分隔
/// </summary>
/// <param name="sperator">分隔符</param>
/// <param name="queries">参数化查询</param>
/// <returns>串联后的结果</returns>
public static ParameterizedQuery Join(this string sperator, params ParameterizedQuery[] queries)
{
if (!queries.Any())
{
return(null);
}
var builder = new ParameterizedQueryBuilder();
queries[0].AppendTo(builder);
foreach (var q in queries.Skip(1))
{
builder.AppendText(sperator);
builder.AppendPartial(q);
}
return(builder.CreateQuery());
}
/// <summary>
/// 串联多个参数化查询对象
/// </summary>
/// <param name="firstQuery">第一个参数化查询对象</param>
/// <param name="otherQueries">要串联的其他参数化查询对象</param>
/// <returns>串联后的参数化查询对象</returns>
public static ParameterizedQuery Concat(this ParameterizedQuery firstQuery, params ParameterizedQuery[] otherQueries)
{
var builder = new ParameterizedQueryBuilder();
firstQuery.AppendTo(builder);
foreach (var query in otherQueries)
{
if (query == null || string.IsNullOrEmpty(query.TextTemplate))
{
continue;
}
if (!builder.IsEndWithWhiteSpace() && !query.IsStartWithWhiteSpace() && Db.AddWhiteSpaceOnConcat)
{
builder.Append(' ');
}
query.AppendTo(builder);
}
return(builder.CreateQuery());
}
/// <summary>
/// 将多个参数化查询串联起来并用指定的字符串分隔
/// </summary>
/// <param name="sperator">分隔符</param>
/// <param name="queries">参数化查询</param>
/// <returns>串联后的结果</returns>
public static ParameterizedQuery Join(this string sperator, params ParameterizedQuery[] queries)
{
if (queries == null)
{
throw new ArgumentNullException("queries");
}
queries = queries.Where(i => i != null).ToArray();//去除所有为 null 的参数化查询对象
if (!queries.Any())
{
return(null);
}
var builder = new ParameterizedQueryBuilder();
queries[0].AppendTo(builder);
foreach (var q in queries.Skip(1))
{
if (!builder.IsEndWithWhiteSpace() && !char.IsWhiteSpace(sperator[0]) && Db.AddWhiteSpaceOnConcat)
{
builder.Append(' ');
}
builder.AppendText(sperator);
if (!builder.IsEndWithWhiteSpace() && !q.IsStartWithWhiteSpace() && Db.AddWhiteSpaceOnConcat)
{
builder.Append(' ');
}
builder.AppendPartial(q);
}
return(builder.CreateQuery());
}
/// <summary>
/// 插入多个实例
/// </summary>
/// <typeparam name="T">实体类型</typeparam>
/// <param name="entity">实体</param>
/// <returns>影响行数</returns>
public static int Insert <T>(List <T> entitys)
{
var type = typeof(T);
var properties = type.GetProperties().Where(p => !GetAttributes(p).OfType <NonFieldAttribute>().Any());
int res = 0;
try
{
using (var tran = db.BeginTransaction())
{
foreach (T entity in entitys)
{
ParameterizedQueryBuilder parms = new ParameterizedQueryBuilder();
StringBuilder strSql = new StringBuilder();
strSql.Append("insert into " + type.Name + "(");
string fields = "";
foreach (var p in properties)
{
var name = GetFieldname(p);
if (name.IndexOf("NOID") == -1)
{
fields += name + ",";
parms.AppendParameter(p.GetValue(entity, null));
}
}
strSql.Append(fields.Substring(0, fields.Length - 1) + ") values({...})");
res += tran.T(strSql.ToString(), parms.CreateQuery().ParameterValues).ExecuteNonQuery();
}
tran.Commit();
}
}
catch
{
res = 0;
}
return(res);
}
/// <summary>
/// 解析查询模板
/// </summary>
/// <param name="builder">参数化查询构建器</param>
/// <param name="templateText">模板文本</param>
/// <param name="args">模板参数</param>
/// <returns>解析结果</returns>
public static ParameterizedQuery ParseTemplate(ParameterizedQueryBuilder builder, string templateText, object[] args)
{
if (args == null)
{
throw new ArgumentNullException("parameters");
}
lock (builder.SyncRoot)
{
for (var i = 0; i < templateText.Length; i++)
{
var ch = templateText[i];
if (ch == '{')
{
if (i == templateText.Length - 1)
{
throw FormatError(templateText, i);
}
if (templateText[i + 1] == '{')
{
i++;
builder.Append('{');
continue;
}
Match match = null;
do
{
match = numberRegex.Match(templateText, i);
if (match.Success)
{
int parameterIndex;
if (!int.TryParse(match.Groups["index"].Value, out parameterIndex))
{
throw FormatError(templateText, i);
}
AddParameter(builder, args[parameterIndex]);
break;
}
match = rangeRegex.Match(templateText, i);
if (match.Success)
{
int begin, end;
if (!int.TryParse(match.Groups["begin"].Value, out begin))
{
throw FormatError(templateText, i);
}
if (match.Groups["end"] != null)
{
if (!int.TryParse(match.Groups["end"].Value, out end))
{
throw FormatError(templateText, i);
}
}
else
{
end = args.Length - 1;
}
if (begin > end || end >= args.Length)
{
throw FormatError(templateText, i);
}
AddParameters(builder, args, begin, end);
break;
}
match = allRegex.Match(templateText, i);
if (match.Success)
{
AddParameters(builder, args, 0, args.Length - 1);
break;
}
} while (false);
if (match == null || !match.Success)
{
throw FormatError(templateText, i);
}
i += match.Length - 1;
}
else if (ch == '}')
{
if (i == templateText.Length - 1)
{
throw FormatError(templateText, i);
}
if (templateText[i + 1] == '}')
{
i++;
builder.Append('}');
continue;
}
}
else
{
builder.Append(ch);
}
}
return(builder.CreateQuery());
}
}
/// <summary>
/// 解析查询模板
/// </summary>
/// <param name="templateText">模板文本</param>
/// <param name="args">模板参数</param>
/// <returns>解析结果</returns>
public static ParameterizedQuery ParseTemplate(string templateText, object[] args)
{
var builder = new ParameterizedQueryBuilder();
return(ParseTemplate(builder, templateText, args));
}
