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"); } }