/// <summary>
/// 读取可空日期型值
/// </summary>
/// <param name="args">对象创建参数</param>
/// <param name="columnName">列名称</param>
/// <returns>日期型结果</returns>
protected DateTimeOffset?LoadNullableDateTimeOffset(EntityCreatingArgs args, String columnName)
{
if (args.Columns.Contains(columnName) && !DbConvert.IsDBNull(args.Row[columnName]))
{
return(DbConvert.ToDateTimeOffset(args.Row[columnName]));
}
else
{
return(null);
}
}
/// <summary>
/// 读取指定类型数据
/// </summary>
/// <param name="args">对象创建参数</param>
/// <param name="columnName">列名称</param>
/// <param name="dataType">数据类型</param>
/// <returns>指定类型数据</returns>
protected Object LoadValue(EntityCreatingArgs args, String columnName, DataType dataType)
{
if (args.Columns.Contains(columnName) && !DbConvert.IsDBNull(args.Row[columnName]))
{
return(DbConvert.ToValue(args.Row[columnName], dataType));
}
else
{
return(DbConvert.GetDefaultValue(dataType));
}
}
/// <summary>
/// 读取可空单精度浮点值
/// </summary>
/// <param name="args">对象创建参数</param>
/// <param name="columnName">列名称</param>
/// <returns>单精度浮点型结果</returns>
protected Single?LoadNullableSingle(EntityCreatingArgs args, String columnName)
{
if (args.Columns.Contains(columnName) && !DbConvert.IsDBNull(args.Row[columnName]))
{
return(DbConvert.ToSingle(args.Row[columnName]));
}
else
{
return(null);
}
}
/// <summary>
/// 读取指定类型数据
/// </summary>
/// <param name="args">对象创建参数</param>
/// <param name="columnName">列名称</param>
/// <param name="dataType">数据类型</param>
/// <typeparam name="TValue">指定类型</typeparam>
/// <returns>指定类型数据</returns>
protected TValue LoadValue <TValue>(EntityCreatingArgs args, String columnName, DataType dataType)
{
if (args.Columns.Contains(columnName) && !DbConvert.IsDBNull(args.Row[columnName]))
{
return((TValue)DbConvert.ToValue(args.Row[columnName], dataType));
}
else
{
return(default(TValue));
}
}
/// <summary>
/// 读取Guid值
/// </summary>
/// <param name="args">对象创建参数</param>
/// <param name="columnName">列名称</param>
/// <returns>Guid结果</returns>
protected Guid LoadGuid(EntityCreatingArgs args, String columnName)
{
if (args.Columns.Contains(columnName) && !DbConvert.IsDBNull(args.Row[columnName]))
{
return(DbConvert.ToGuid(args.Row[columnName]));
}
else
{
return(default(Guid));
}
}
/// <summary>
/// 读取字符串
/// </summary>
/// <param name="args">对象创建参数</param>
/// <param name="columnName">列名称</param>
/// <returns>字符串结果</returns>
protected String LoadString(EntityCreatingArgs args, String columnName)
{
if (args.Columns.Contains(columnName) && !DbConvert.IsDBNull(args.Row[columnName]))
{
return(DbConvert.ToString(args.Row[columnName]));
}
else
{
return(String.Empty);
}
}
/// <summary>
/// 读取8字节无符号整型值
/// </summary>
/// <param name="args">对象创建参数</param>
/// <param name="columnName">列名称</param>
/// <returns>8字节无符号整型结果</returns>
protected UInt64 LoadUInt64(EntityCreatingArgs args, String columnName)
{
if (args.Columns.Contains(columnName) && !DbConvert.IsDBNull(args.Row[columnName]))
{
return(DbConvert.ToUInt64(args.Row[columnName]));
}
else
{
return(default(UInt64));
}
}
/// <summary>
/// 读取日期型值
/// </summary>
/// <param name="args">对象创建参数</param>
/// <param name="columnName">列名称</param>
/// <returns>日期型结果</returns>
protected DateTime LoadDateTime(EntityCreatingArgs args, String columnName)
{
if (args.Columns.Contains(columnName) && !DbConvert.IsDBNull(args.Row[columnName]))
{
return(DbConvert.ToDateTime(args.Row[columnName]));
}
else
{
return(default(DateTime));
}
}
/// <summary>
/// 读取4字节整型值
/// </summary>
/// <param name="args">对象创建参数</param>
/// <param name="columnName">列名称</param>
/// <returns>4字节整型结果</returns>
protected Int32 LoadInt32(EntityCreatingArgs args, String columnName)
{
if (args.Columns.Contains(columnName) && !DbConvert.IsDBNull(args.Row[columnName]))
{
return(DbConvert.ToInt32(args.Row[columnName]));
}
else
{
return(default(Int32));
}
}
/// <summary>
/// 读取字节型值
/// </summary>
/// <param name="args">对象创建参数</param>
/// <param name="columnName">列名称</param>
/// <returns>字节型结果</returns>
protected Char LoadChar(EntityCreatingArgs args, String columnName)
{
if (args.Columns.Contains(columnName) && !DbConvert.IsDBNull(args.Row[columnName]))
{
return(DbConvert.ToChar(args.Row[columnName]));
}
else
{
return(default(Char));
}
}
/// <summary>
/// 读取布尔型值
/// </summary>
/// <param name="args">对象创建参数</param>
/// <param name="columnName">列名称</param>
/// <returns>布尔型结果</returns>
protected Boolean LoadBoolean(EntityCreatingArgs args, String columnName)
{
if (args.Columns.Contains(columnName) && !DbConvert.IsDBNull(args.Row[columnName]))
{
return(DbConvert.ToBoolean(args.Row[columnName]));
}
else
{
return(default(Boolean));
}
}
/// <summary>
/// 读取指定类型数据
/// </summary>
/// <param name="args">对象创建参数</param>
/// <param name="columnName">列名称</param>
/// <param name="dataType">数据类型</param>
/// <typeparam name="TValue">指定类型</typeparam>
/// <returns>指定类型数据</returns>
protected Nullable <TValue> LoadNullableValue <TValue>(EntityCreatingArgs args, String columnName, DataType dataType) where TValue : struct
{
if (args.Columns.Contains(columnName) && !DbConvert.IsDBNull(args.Row[columnName]))
{
return((TValue)DbConvert.ToValue(args.Row[columnName], dataType));
}
else
{
return(null);
}
}
/// <summary>
/// 读取字节数组
/// </summary>
/// <param name="args">对象创建参数</param>
/// <param name="columnName">列名称</param>
/// <returns>字节数组结果</returns>
protected Byte[] LoadNullableBytes(EntityCreatingArgs args, String columnName)
{
if (args.Columns.Contains(columnName) && !DbConvert.IsDBNull(args.Row[columnName]))
{
return(args.Row[columnName] as Byte[]);
}
else
{
return(null);
}
}
/// <summary>
/// 读取指定类型数据
/// </summary>
/// <param name="row">数据行</param>
/// <param name="columns">数据列集合</param>
/// <param name="columnName">列名称</param>
/// <typeparam name="TValue">指定类型</typeparam>
/// <returns>指定类型数据</returns>
internal TValue LoadValue <TValue>(DataRow row, DataColumnCollection columns, String columnName)
{
if (columns.Contains(columnName) && !DbConvert.IsDBNull(row[columnName]))
{
Object value = row[columnName];
DataType dataType = DataTypeHelper.InternalGetDataType(value);
return((TValue)DbConvert.ToValue(value, dataType));
}
else
{
return(default(TValue));
}
}
/// <summary>
/// 获取提交统计信息
/// </summary>
/// <param name="dtStart">开始日期</param>
/// <param name="dtEnd">结束日期</param>
/// <param name="acceptedOnly">是否仅有AC题目</param>
/// <returns>提交统计信息</returns>
public IDictionary <Int32, Int32> GetSubmitStatus(DateTime dtStart, DateTime dtEnd, Boolean acceptedOnly)
{
//SELECT COUNT(*) AS SOLU_COUNT, #DatePart(SOLU_SUBMITTIME)# AS SOLU_SUBMITDATE
//FROM SDNUOJ_SOLUTION
//WHERE CONDITION
//GROUP BY #DatePart(SOLU_SUBMITTIME)#
SortedDictionary <Int32, Int32> submits = new SortedDictionary <Int32, Int32>();
return(this.Select()
.Query(SqlAggregateFunction.Count, SOLUTIONID, "SOLU_COUNT")
.Query(this.Functions.DatePart(SUBMITTIME, SqlDatePartType.DayOfMonth), "SOLU_SUBMITDATE")
.Where(c =>
{
AbstractSqlCondition condition = c.Between(SUBMITTIME, dtStart, dtEnd);
if (acceptedOnly)
{
condition = condition & c.Equal(RESULT, (Byte)ResultType.Accepted);
}
return condition;
})
.GroupBy(this.Functions.DatePart(SUBMITTIME, SqlDatePartType.DayOfMonth))
.ToDataTable()
.Each(args =>
{
if (!DbConvert.IsDBNull(args.Row["SOLU_SUBMITDATE"]))
{
Int32 dayOfMonth = this.LoadInt32(args, "SOLU_SUBMITDATE");
Int32 count = this.LoadInt32(args, "SOLU_COUNT");
submits[dayOfMonth] = count;
}
})
.Done(submits));
}
/// <summary>
/// 获取竞赛用户排名数据
/// </summary>
/// <param name="cid">竞赛ID</param>
/// <param name="start">竞赛开始时间</param>
/// <returns>用户排名数据</returns>
public Dictionary <String, RankItem> GetContestRanklist(Int32 cid, DateTime start)
{
return(this.UsingConnection <Dictionary <String, RankItem> >(conn =>
{
Dictionary <String, RankItem> rank = new Dictionary <String, RankItem>();
HashSet <Int32> firstBlooded = new HashSet <Int32>();
//获取AC用户列表
this.Select()
.Querys(USERNAME, CONTESTPROBLEMID, SUBMITTIME)
.Where(c => c.Equal(CONTESTID, cid) & c.Equal(RESULT, (Byte)ResultType.Accepted))
.OrderByAsc(SUBMITTIME)
.ToDataTable(conn)
.Each(args =>
{
if (DbConvert.IsDBNull(args.Row[CONTESTPROBLEMID]))
{
return;
}
String userName = this.LoadString(args, USERNAME);
Int32 contestProblemID = this.LoadInt32(args, CONTESTPROBLEMID);
DateTime submitTime = this.LoadDateTime(args, SUBMITTIME);
RankItem userRank = null;
if (!rank.TryGetValue(userName, out userRank))
{
userRank = new RankItem(userName);
}
if (!userRank.Penaltys.ContainsKey(contestProblemID))
{
Boolean firstBlood = false;
if (!firstBlooded.Contains(contestProblemID))
{
firstBlood = true;
firstBlooded.Add(contestProblemID);
}
userRank.AddAcceptedProblem(contestProblemID, submitTime - start, firstBlood);
rank[userName] = userRank;
}
});
//获取错误用户列表
this.Select()
.Querys(USERNAME, CONTESTPROBLEMID)
.Query(SqlAggregateFunction.Count, SOLUTIONID, "SOLU_WRONGCOUNT")
.Where(c => c.Equal(CONTESTID, cid) & c.LessThan(RESULT, (Byte)ResultType.Accepted))
.GroupByThese(USERNAME, CONTESTPROBLEMID)
.ToDataTable(conn)
.Each(args =>
{
if (DbConvert.IsDBNull(args.Row[CONTESTPROBLEMID]))
{
return;
}
String userName = this.LoadString(args, USERNAME);
Int32 contestProblemID = this.LoadInt32(args, CONTESTPROBLEMID);
Int32 wrongCount = this.LoadInt32(args, "SOLU_WRONGCOUNT");
RankItem userRank = null;
if (!rank.TryGetValue(userName, out userRank))
{
userRank = new RankItem(userName);
}
userRank.AddWrongProblemCount(contestProblemID, wrongCount);
rank[userName] = userRank;
});
return rank;
}));
}
