public virtual void AppendScopeIdentity(StringBuilder builder, DataAspect aspect)
{
builder.Append("SELECT MAX(");
AppendName(builder, aspect.IdentityMember.StoredName);
builder.Append(") FROM ");
AppendName(builder, aspect.StoredName);
}
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 (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));
}
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 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 virtual DatabaseCommand CreateSelect(DataAspect aspect, ClassFilter filter, ClassSort sort, int pageSize, int pageOrdinal)
{
StringBuilder builder = new StringBuilder(255);
int count = aspect.Count;
builder.Append("SELECT ");
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 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 AppendSortNodes(StringBuilder builder, DataAspect aspect, ClassSortNode node)
{
AppendSort(builder, aspect, node.Term);
if (node.Next != null)
{
builder.Append(", ");
AppendSortNodes(builder, aspect, node.Next);
}
}
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 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 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 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 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 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 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 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 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));
}
/// <summary>
/// Enumerates values for an update by primary key.
/// </summary>
/// <param name="aspect">The data aspect to use.</param>
/// <param name="entity">The entity to query.</param>
/// <returns>An enumeration of aspect member values.</returns>
private IEnumerable <AspectMemberValue> EnumerateValuesForUpdateByPrimaryKey(DataAspect aspect, object entity)
{
int count = aspect.Count;
int identityOrdinal = aspect.IdentityOrdinal;
for (int i = 0; i < count; i++)
{
if (i != identityOrdinal && !aspect[i].IsPrimaryKey && aspect[i].IncludeInScope(DataScope.Update))
{
yield return(new AspectMemberValue(
aspect,
i,
aspect[i].GetValue(entity, DataScope.Update)));
}
}
}
/// <summary>
/// Enumerates values for an insert or update excluding specific member.
/// </summary>
/// <param name="aspect">The data aspect of the class.</param>
/// <param name="entity">The entity to query.</param>
/// <param name="scope">The scope of the command.</param>
/// <param name="ordinal">The ordinal position to exclude.</param>
/// <returns>An enumeration of aspect member values.</returns>
private IEnumerable <AspectMemberValue> EnumerateValuesExcludingMember(DataAspect aspect, object entity, DataScope scope, int ordinal)
{
int count = aspect.Count;
int identityOrdinal = aspect.IdentityOrdinal;
for (int i = 0; i < count; i++)
{
if (i != identityOrdinal && i != ordinal && aspect[i].IncludeInScope(scope))
{
yield return(new AspectMemberValue(
aspect,
i,
aspect[i].GetValue(entity, scope)));
}
}
}
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 CreateSelectCount(DataAspect aspect, ClassFilter filter)
{
StringBuilder builder = new StringBuilder(255);
int count = aspect.Count;
builder.Append("SELECT COUNT(*) 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 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 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 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 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));
}
/// <summary>
/// Constructs a class select.
/// </summary>
/// <param name="storage">The storage to read from.</param>
/// <param name="aspect">The data aspect of the class</param>
public ClassSelect(ClassStorageEngine storage, DataAspect aspect)
{
this._Storage = storage;
this._Aspect = aspect;
}
public virtual void AppendFilterExpression(StringBuilder builder, DataAspect aspect, ClassFilterExpression expression)
{
builder.Append("(");
AppendFilterNodes(builder, aspect, expression.First);
builder.Append(")");
}
public virtual void AppendSortExpression(StringBuilder builder, DataAspect aspect, ClassSortExpression expression)
{
AppendSortNodes(builder, aspect, expression.First);
}
public DatabaseStorage(Database database, DataAspect aspect)
: base(database, aspect)
{
this._Database = database;
}
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");
}
}
