public override void AppendSortTerm(StringBuilder builder, DataAspect aspect, ClassSortTerm term)
{
if (term.Direction == EixoX.Data.SortDirection.Random)
builder.Append(" NEWID()");
else
base.AppendSortTerm(builder, aspect, term);
}
public ClassFilter CreateSearchFilter(DataAspect aspect, string filter)
{
if (string.IsNullOrEmpty(filter))
{
return(null);
}
else if (filter.Length < 3)
{
filter = filter + "%";
}
else
{
filter = "%" + filter.Replace(' ', '%') + "%";
}
Type stringType = typeof(string);
ClassFilterExpression expression = null;
DataAspect dataAspect = aspect;
int count = dataAspect.Count;
for (int i = 0; i < count; i++)
{
//if (dataAspect[i].DataType == stringType)
expression =
expression == null ?
new ClassFilterExpression(dataAspect, i, FilterComparison.Like, filter) :
expression.Or(i, FilterComparison.Like, filter);
}
return(expression);
}
public int Insert(DataAspect aspect, IEnumerable <AspectMemberValue> values, out object identityValue)
{
using (IDbConnection conn = _dialect.CreateConnection(_ConnectionString))
{
conn.Open();
try
{
bool hasIdentity;
DatabaseCommand cmd = _dialect.CreateInsert(aspect, values, out hasIdentity);
if (hasIdentity)
{
identityValue = cmd.ExecuteScalar(conn);
return(1);
}
else
{
identityValue = null;
return(cmd.ExecuteNonQuery(conn));
}
}
finally
{
conn.Close();
}
}
}
public IEnumerable <T> Select <T>(DataAspect aspect, ClassFilter filter, ClassSort sort, int pageSize, int pageOrdinal)
{
using (IDbConnection conn = _dialect.CreateConnection(_ConnectionString))
{
conn.Open();
try
{
IEnumerable <IDataRecord> records = _dialect.CreateSelect(aspect, filter, sort, pageSize, pageOrdinal).ExecuteQuery(conn);
if (pageSize > 0 && pageOrdinal >= 0)
{
if (!_dialect.CanOffsetRecords)
{
if (!_dialect.CanLimitRecords)
{
records = new Collections.EnumerablePager <IDataRecord>(records, pageSize, pageOrdinal);
}
else
{
records = new Collections.EnumerableOffset <IDataRecord>(records, pageSize * pageOrdinal);
}
}
else if (!_dialect.CanLimitRecords)
{
records = new Collections.EnumerableLimit <IDataRecord>(records, pageSize);
}
}
using (IEnumerator <IDataRecord> e = records.GetEnumerator())
{
if (e.MoveNext())
{
bool initializable = typeof(Initializable).IsAssignableFrom(aspect.DataType);
int count = e.Current.FieldCount;
do
{
T entity = (T)aspect.NewInstance();
for (int i = 0; i < count; i++)
{
if (!e.Current.IsDBNull(i))
{
aspect[i].SetValue(entity, e.Current.GetValue(i));
}
}
if (initializable)
{
((Initializable)entity).Initialize();
}
yield return(entity);
} while (e.MoveNext());
}
}
}
finally
{
conn.Close();
}
}
}
public virtual void AppendFilter(StringBuilder builder, DataAspect aspect, ClassFilter filter)
{
if (filter is ClassFilterTerm)
AppendFilterTerm(builder, aspect, (ClassFilterTerm)filter);
else if (filter is ClassFilterNode)
AppendFilterNodes(builder, aspect, (ClassFilterNode)filter);
else if (filter is ClassFilterExpression)
AppendFilterExpression(builder, aspect, (ClassFilterExpression)filter);
else
throw new ArgumentException("Unknown filter type: " + filter.GetType(), "filter");
}
public object GetMemberValue(DataAspect aspect, int ordinal, ClassFilter filter)
{
using (IDbConnection conn = _dialect.CreateConnection(_ConnectionString))
{
conn.Open();
try
{
return(_dialect.CreateSelectMember(aspect, ordinal, filter, null, 0, 0).ExecuteScalar(conn));
}
finally
{
conn.Close();
}
}
}
public bool Exists(DataAspect aspect, ClassFilter filter)
{
using (IDbConnection conn = _dialect.CreateConnection(_ConnectionString))
{
conn.Open();
try
{
return(Convert.ToInt32(_dialect.CreateSelectExists(aspect, filter).ExecuteScalar(conn)) == 1);
}
finally
{
conn.Close();
}
}
}
public int Insert(DataAspect aspect, System.Collections.IEnumerable entities)
{
using (IDbConnection conn = _dialect.CreateConnection(_ConnectionString))
{
conn.Open();
try
{
return(_dialect.CreateInsert(aspect, entities).ExecuteNonQuery(conn));
}
finally
{
conn.Close();
}
}
}
public int Delete(DataAspect aspect, ClassFilter filter)
{
using (IDbConnection conn = _dialect.CreateConnection(_ConnectionString))
{
conn.Open();
try
{
return(_dialect.CreateDelete(aspect, filter).ExecuteNonQuery(conn));
}
finally
{
conn.Close();
}
}
}
public int Update(DataAspect aspect, IEnumerable <AspectMemberValue> values, ClassFilter filter)
{
using (IDbConnection conn = _dialect.CreateConnection(_ConnectionString))
{
conn.Open();
try
{
return(_dialect.CreateUpdate(aspect, values, filter).ExecuteNonQuery(conn));
}
finally
{
conn.Close();
}
}
}
public long Count(DataAspect aspect, ClassFilter filter)
{
using (IDbConnection conn = _dialect.CreateConnection(_ConnectionString))
{
conn.Open();
try
{
return(Convert.ToInt64(_dialect.CreateSelectCount(aspect, filter).ExecuteScalar(conn)));
}
finally
{
conn.Close();
}
}
}
public virtual void AppendFilterNodes(StringBuilder builder, DataAspect aspect, ClassFilterNode node)
{
AppendFilter(builder, aspect, node.Filter);
if (node.Next != null)
{
switch (node.Operation)
{
case FilterOperation.And:
builder.Append(" AND ");
break;
case FilterOperation.Or:
builder.Append(" OR ");
break;
default:
throw new ArgumentException("Unknown filter operation " + node.Operation, "node");
}
AppendFilterNodes(builder, aspect, node.Next);
}
}
public IEnumerable <object> SelectMember(DataAspect aspect, int ordinal, ClassFilter filter, ClassSort sort, int pageSize, int pageOrdinal)
{
using (IDbConnection conn = _dialect.CreateConnection(_ConnectionString))
{
conn.Open();
try
{
IEnumerable <IDataRecord> records = _dialect.CreateSelectMember(aspect, ordinal, filter, sort, pageSize, pageOrdinal).ExecuteQuery(conn);
if (pageSize > 0 && pageOrdinal >= 0)
{
if (!_dialect.CanOffsetRecords)
{
if (!_dialect.CanLimitRecords)
{
records = new Collections.EnumerablePager <IDataRecord>(records, pageSize, pageOrdinal);
}
else
{
records = new Collections.EnumerableOffset <IDataRecord>(records, pageSize * pageOrdinal);
}
}
else if (!_dialect.CanLimitRecords)
{
records = new Collections.EnumerableLimit <IDataRecord>(records, pageSize);
}
}
foreach (IDataRecord record in records)
{
yield return(record.GetValue(0));
}
}
finally
{
conn.Close();
}
}
}
public override DatabaseCommand CreateSelect(DataAspect aspect, ClassFilter filter, ClassSort sort, int pageSize, int pageOrdinal)
{
StringBuilder builder = new StringBuilder(255);
int count = aspect.Count;
builder.Append("SELECT ");
if (pageSize > 0 && pageOrdinal >= 0)
{
builder.Append("TOP ");
builder.Append((pageOrdinal + 1) * pageSize);
builder.Append(' ');
}
AppendName(builder, aspect[0].StoredName);
for (int i = 1; i < count; i++)
{
builder.Append(", ");
AppendName(builder, aspect[i].StoredName);
}
builder.Append(" FROM ");
AppendName(builder, aspect.StoredName);
if (filter != null)
{
builder.Append(" WHERE ");
AppendFilter(builder, aspect, filter);
}
if (sort != null)
{
builder.Append(" ORDER BY ");
AppendSort(builder, aspect, sort);
}
return new DatabaseCommand(
CommandType.Text,
builder.ToString(),
null);
}
public virtual DatabaseCommand CreateInsert(DataAspect aspect, IEnumerable<AspectMemberValue> values, out bool hasScopeIdentity)
{
StringBuilder builder = new StringBuilder(512);
StringBuilder valueBuilder = new StringBuilder(255);
builder.Append("INSERT INTO ");
AppendName(builder, aspect.StoredName);
builder.Append(" (");
bool prependComma = false;
foreach (AspectMemberValue value in values)
{
if (prependComma)
{
builder.Append(", ");
valueBuilder.Append(", ");
}
else
prependComma = true;
AppendName(builder, aspect[value.Ordinal].StoredName);
AppendValue(valueBuilder, value.Value);
}
builder.Append(") VALUES (");
builder.Append(valueBuilder);
if (aspect.HasIdentity)
{
hasScopeIdentity = true;
builder.Append("); ");
AppendScopeIdentity(builder, aspect);
}
else
{
hasScopeIdentity = false;
builder.Append(")");
}
return new DatabaseCommand(
CommandType.Text,
builder.ToString(),
null);
}
public virtual DatabaseCommand CreateDelete(DataAspect aspect, ClassFilter filter)
{
StringBuilder builder = new StringBuilder(255);
builder.Append("DELETE FROM ");
AppendName(builder, aspect.StoredName);
if (filter != null)
{
builder.Append(" WHERE ");
AppendFilter(builder, aspect, filter);
}
return new DatabaseCommand(
CommandType.Text,
builder.ToString(),
null);
}
public virtual void AppendSortTerm(StringBuilder builder, DataAspect aspect, ClassSortTerm term)
{
if (term.Direction != EixoX.Data.SortDirection.Random)
{
AppendName(builder, aspect[term.Ordinal].StoredName);
if (term.Direction == EixoX.Data.SortDirection.Descending)
builder.Append(" DESC");
}
}
public virtual void AppendSortNodes(StringBuilder builder, DataAspect aspect, ClassSortNode node)
{
AppendSort(builder, aspect, node.Term);
if (node.Next != null)
{
builder.Append(", ");
AppendSortNodes(builder, aspect, node.Next);
}
}
public virtual void AppendSortExpression(StringBuilder builder, DataAspect aspect, ClassSortExpression expression)
{
AppendSortNodes(builder, aspect, expression.First);
}
public virtual void AppendSort(StringBuilder builder, DataAspect aspect, ClassSort sort)
{
if (sort is ClassSortNode)
AppendSortNodes(builder, aspect, (ClassSortNode)sort);
else if (sort is ClassSortTerm)
AppendSortTerm(builder, aspect, (ClassSortTerm)sort);
else if (sort is ClassSortExpression)
AppendSortExpression(builder, aspect, (ClassSortExpression)sort);
else
throw new ArgumentException("Unknown sort type " + sort.GetType(), "sort");
}
public virtual void AppendScopeIdentity(StringBuilder builder, DataAspect aspect)
{
builder.Append("SELECT MAX(");
AppendName(builder, aspect.IdentityMember.StoredName);
builder.Append(") FROM ");
AppendName(builder, aspect.StoredName);
}
/// <summary>Returns rune data for a champion</summary>
/// <param name="ChampionKey"></param>
/// <param name="DataAspect"></param>
/// <param name="CancelToken"></param>
/// <returns>Task to get rune data</returns>
public Task <List <RuneSet> > GetRunes(string ChampionKey, DataAspect DataAspect, CancellationToken CancelToken)
{
return(Get <List <RuneSet> >("champion/" + ChampionKey + "/runes/" + DataAspect, CancelToken));
}
// items
/// <summary>Returns item data for a champion</summary>
/// <param name="ChampionKey"></param>
/// <param name="DataAspect"></param>
/// <param name="ItemAspect"></param>
/// <returns>Task to get item data</returns>
public Task <List <ItemSet> > GetItems(string ChampionKey, DataAspect DataAspect, ItemAspect ItemAspect)
{
return(GetItems(ChampionKey, DataAspect, ItemAspect, CancellationToken.None));
}
public virtual DatabaseCommand CreateSelectMember(DataAspect aspect, int ordinal, ClassFilter filter, ClassSort sort, int pageSize, int pageOrdinal)
{
StringBuilder builder = new StringBuilder(255);
int count = aspect.Count;
builder.Append("SELECT ");
AppendName(builder, aspect[ordinal].StoredName);
builder.Append(" FROM ");
AppendName(builder, aspect.StoredName);
if (filter != null)
{
builder.Append(" WHERE ");
AppendFilter(builder, aspect, filter);
}
if (sort != null)
{
builder.Append(" ORDER BY ");
AppendSort(builder, aspect, sort);
}
return new DatabaseCommand(
CommandType.Text,
builder.ToString(),
null);
}
public virtual DatabaseCommand CreateInsert(DataAspect aspect, System.Collections.IEnumerable entities)
{
StringBuilder builder = new StringBuilder(1024);
int identityOrdinal = aspect.IdentityOrdinal;
int count = aspect.Count;
builder.Append("INSERT INTO ");
AppendName(builder, aspect.StoredName);
builder.Append("(");
bool prependComma = false;
for (int i = 0; i < count; i++)
if (i != identityOrdinal)
{
if (prependComma)
builder.Append(", ");
else
prependComma = true;
AppendName(builder, aspect[i].StoredName);
}
builder.Append(") VALUES ");
prependComma = false;
foreach (object entity in entities)
{
if (prependComma)
builder.Append(", ");
else
prependComma = true;
builder.Append("(");
bool innerComma = false;
for (int i = 0; i < count; i++)
if (i != identityOrdinal)
{
if (innerComma)
builder.Append(", ");
else
innerComma = true;
AppendValue(builder, aspect[i].GetValue(entity, DataScope.Insert));
}
builder.Append(")");
}
return new DatabaseCommand(
CommandType.Text,
builder.ToString(),
null);
}
// summoner spells
/// <summary>Returns summoner spell data for a champion</summary>
/// <param name="ChampionKey"></param>
/// <param name="DataAspect"></param>
/// <returns>Task to get summoner spell data</returns>
public Task <List <SummonerSet> > GetSummoners(string ChampionKey, DataAspect DataAspect)
{
return(GetSummoners(ChampionKey, DataAspect, CancellationToken.None));
}
/// <summary>
/// Construct class insert.
/// </summary>
/// <param name="storage">The storage to use.</param>
/// <param name="aspect">The aspect to use.</param>
public ClassInsert(ClassStorageEngine storage, DataAspect aspect)
{
this._Storage = storage;
this._Aspect = aspect;
this._Values = new LinkedList<AspectMemberValue>();
}
/// <summary>Returns summoner spell data for a champion</summary>
/// <param name="ChampionKey"></param>
/// <param name="DataAspect"></param>
/// <param name="CancelToken"></param>
/// <returns>Task to get summoner spell data</returns>
public Task <List <SummonerSet> > GetSummoners(string ChampionKey, DataAspect DataAspect, CancellationToken CancelToken)
{
return(Get <List <SummonerSet> >("champion/" + ChampionKey + "/summoners/" + DataAspect, CancelToken));
}
public virtual DatabaseCommand CreateSelectExists(DataAspect aspect, ClassFilter filter)
{
StringBuilder builder = new StringBuilder(255);
int count = aspect.Count;
builder.Append("SELECT 1 WHERE EXISTS (SELECT * FROM ");
AppendName(builder, aspect.StoredName);
if (filter != null)
{
builder.Append(" WHERE ");
AppendFilter(builder, aspect, filter);
}
builder.Append(")");
return new DatabaseCommand(
CommandType.Text,
builder.ToString(),
null);
}
/// <summary>Returns skill data for a champion</summary>
/// <param name="ChampionKey"></param>
/// <param name="DataAspect"></param>
/// <param name="CancelToken"></param>
/// <returns>Task to get skill data</returns>
public Task <List <SkillSet> > GetSkills(string ChampionKey, DataAspect DataAspect, CancellationToken CancelToken)
{
return(Get <List <SkillSet> >("champion/" + ChampionKey + "/skills/" + DataAspect, CancelToken));
}
public virtual DatabaseCommand CreateUpdate(DataAspect aspect, IEnumerable<AspectMemberValue> values, ClassFilter filter)
{
StringBuilder builder = new StringBuilder(512);
builder.Append("UPDATE ");
AppendName(builder, aspect.StoredName);
builder.Append(" SET ");
bool prependComma = false;
foreach (AspectMemberValue value in values)
{
if (!value.Member.HasAttribute<NonUpdateable>(false))
{
if (prependComma)
builder.Append(", ");
else
prependComma = true;
AppendName(builder, aspect[value.Ordinal].StoredName);
builder.Append(" = ");
AppendValue(builder, value.Value);
}
}
if (filter != null)
{
builder.Append(" WHERE ");
AppendFilter(builder, aspect, filter);
}
return new DatabaseCommand(
CommandType.Text,
builder.ToString(),
null);
}
/// <summary>Returns item data for a champion</summary>
/// <param name="ChampionKey"></param>
/// <param name="DataAspect"></param>
/// <param name="ItemAspect"></param>
/// <param name="CancelToken"></param>
/// <returns>Task to get item data</returns>
public Task <List <ItemSet> > GetItems(string ChampionKey, DataAspect DataAspect, ItemAspect ItemAspect, CancellationToken CancelToken)
{
return(Get <List <ItemSet> >("champion/" + ChampionKey + "/items/" + ItemAspect + "/" + DataAspect, CancelToken));
}
public virtual void AppendFilterExpression(StringBuilder builder, DataAspect aspect, ClassFilterExpression expression)
{
builder.Append("(");
AppendFilterNodes(builder, aspect, expression.First);
builder.Append(")");
}
/// <summary>Returns rune data for a champion</summary>
/// <param name="ChampionKey"></param>
/// <param name="DataAspect"></param>
/// <returns>Task to get rune data</returns>
public Task <List <RuneSet> > GetRunes(string ChampionKey, DataAspect DataAspect)
{
return(GetRunes(ChampionKey, DataAspect, CancellationToken.None));
}
public virtual void AppendFilterTerm(StringBuilder builder, DataAspect aspect, ClassFilterTerm term)
{
AppendName(builder, aspect[term.Ordinal].StoredName);
switch (term.Comparison)
{
case FilterComparison.EqualTo:
if (term.Value == null)
builder.Append(" IS NULL");
else
{
builder.Append(" = ");
AppendValue(builder, term.Value);
}
break;
case FilterComparison.GreaterOrEqual:
builder.Append(" >= ");
AppendValue(builder, term.Value);
break;
case FilterComparison.GreaterThan:
builder.Append(" > ");
AppendValue(builder, term.Value);
break;
case FilterComparison.InCollection:
builder.Append(" IN ");
AppendValue(builder, term.Value);
break;
case FilterComparison.Like:
builder.Append(" LIKE ");
AppendValue(builder, term.Value);
break;
case FilterComparison.LowerOrEqual:
builder.Append(" <= ");
AppendValue(builder, term.Value);
break;
case FilterComparison.LowerThan:
builder.Append(" < ");
AppendValue(builder, term.Value);
break;
case FilterComparison.NotEqualTo:
if (term.Value == null)
builder.Append(" IS NOT NULL");
else
{
builder.Append(" != ");
AppendValue(builder, term.Value);
}
break;
case FilterComparison.NotInCollection:
builder.Append(" NOT IN ");
AppendValue(builder, term.Value);
break;
case FilterComparison.NotLike:
builder.Append(" NOT LIKE ");
AppendValue(builder, term.Value);
break;
default:
throw new ArgumentException("Unknown filter comparion " + term.Comparison, "term");
}
}
public override void AppendScopeIdentity(StringBuilder builder, DataAspect aspect)
{
builder.Append("SELECT SCOPE_IDENTITY()");
}
