Grouping.GroupCollection Grouping.IGroupAlgorithm.Group(Column sourceColumn, ArrayRange indices, SortOrder order) { DupCollection coll = new DupCollection(); if (order == SortOrder.None) { order = SortOrder.Ascending; } coll.m_sortedIndex = sourceColumn.GetSortIndex(order, indices, false); System.Collections.Generic.List <DupGroup> groups = new System.Collections.Generic.List <DupGroup>(); int iGroupFirst = 0; for (int i = 1, j = 0; i < coll.m_sortedIndex.Length; j = i++) { if (sourceColumn.CompareRow(coll.m_sortedIndex[j], coll.m_sortedIndex[i]) != 0) { //create group; Range range = Range.FirstToLast(iGroupFirst, i); groups.Add(new DupGroup(range)); iGroupFirst = i; } } Range rangeLast = Range.FirstToLast(iGroupFirst, coll.m_sortedIndex.Length); if (rangeLast.Length > 0) { groups.Add(new DupGroup(rangeLast)); } coll.m_Groups = groups.ToArray(); return(coll); }
public IComparable Merge(Column sourceColumn, ArrayRange sourceIndices) { return(GroupTyped(sourceColumn as ColumnTyped <DataT>, sourceIndices)); }
//returning indice array is always in ascending index order public abstract long[] GetMatchIndex(ArrayRange rowRange, Operation.Operator op, Operation.Expression exp, long expRowFirst, bool rowToRow);
public Group(ArrayRange indices) { m_GroupIndice = indices; }
protected override IComparable GroupTyped(ColumnTyped <DataT> sourceColumn, ArrayRange sourceIndices) { return(sourceColumn.GetRowValue(sourceIndices[0])); }
protected override void GroupTyped(ColumnTyped <DataT> destColumn, long destRow, ColumnTyped <DataT> sourceColumn, ArrayRange sourceIndices) { destColumn.SetRowValue(destRow, (DataT)GroupTyped(sourceColumn, sourceIndices)); }
public override long[] GetMatchIndex(ArrayRange indices, Database.Operation.Matcher matcher) { return(GetMatchIndex(indices, matcher, new Database.Operation.ExpColumn <DataT>(this))); }
protected abstract void GroupTyped(ColumnTyped <DataT> destColumn, long destRow, ColumnTyped <DataT> sourceColumn, ArrayRange sourceIndices);
public abstract Database.Table CreateFilter(Database.Table tableIn, ArrayRange range);
private static int RenderCore( HtmlRenderingContext context, ArrayRange <RenderTreeFrame> frames, int position) { ref var frame = ref frames.Array[position];
/// <summary> /// returns undo <see cref="Query"/> corresponding to query performed on /// <paramref name="auditedTableName"/>, where <paramref name="auditTableRow"/> contains /// the data required to undo a single row in <paramref name="auditedTableName"/>, /// which was affected by the query. /// </summary> /// <param name="auditTableRow"></param> /// <param name="auditedTableName"></param> /// <param name="queryTypeIdToQueryType"></param> /// <returns> /// undo <see cref="Query"/> corresponding to query performed on /// <paramref name="auditedTableName"/>, where <paramref name="auditTableRow"/> contains /// the data required to undo a single row in <paramref name="auditedTableName"/>, /// which was affected by the query /// </returns> /// <exception cref="UnsupportedAuditQueryTypeException"> /// thrown if <see cref="Query.eQueryType"/> specified in <paramref name="auditTableRow"/> /// is not supported for audit /// </exception> private static WriteQuery getUndoQuery( ResultSet.Row auditTableRow, string auditedTableName, Dictionary <long, Query.eQueryType> queryTypeIdToQueryType) { WriteQuery undoQuery; // type of query that was originally performed on audited table long queryTypeId = auditTableRow.GetColumnValue <long>( AuditTableStructure.QUERY_ID_COLUMN_INDEX); Query.eQueryType queryType = queryTypeIdToQueryType[queryTypeId]; // value of _id column of modified row in audit table long auditedTableRowId = auditTableRow.GetColumnValue <long>( AuditTableStructure.AUDITED_TABLE_ROW_ID_COLUMN_INDEX); // get undo query based on query type if (queryType == Query.eQueryType.Insert) { undoQuery = new DeleteQuery( auditedTableName, new BasicCondition( new ValuedTableColumn( DatabaseStructure.ID_COLUMN_NAME, auditedTableName, auditedTableRowId), BasicCondition.eOperatorType.Equal ) ); } else if (queryType == Query.eQueryType.Update || queryType == Query.eQueryType.Delete) { // ValuedColumn of _id column of modified row in audited table ArrayRange <ValuedColumn> auditedTableRowIdArrayRange = new ArrayRange <ValuedColumn>( new ValuedColumn(DatabaseStructure.ID_COLUMN_NAME, auditedTableRowId) ); // ValueColumn of columns other than _id of modified row in audited table ArrayRange <ValuedColumn> auditedTableRowValuesArrayRange = new ArrayRange <ValuedColumn>( ValuedColumn.Parse(auditTableRow.ColumnNames, auditTableRow.ColumnValues), AuditTableStructure.AUDITED_TABLE_DATA_COLUMNS_START_INDEX); // unified ValuedColumn list for undo query List <ValuedColumn> queryValuedColumns = ListUtils.ListFromArrayRanges( auditedTableRowIdArrayRange, auditedTableRowValuesArrayRange); if (queryType == Query.eQueryType.Update) { undoQuery = new UpdateQuery( auditedTableName, queryValuedColumns, new BasicCondition( new ValuedTableColumn( DatabaseStructure.ID_COLUMN_NAME, auditedTableName, auditedTableRowId), BasicCondition.eOperatorType.Equal ) ); } else // queryType == Query.eQueryType.Delete { undoQuery = new InsertQuery(auditedTableName, queryValuedColumns); } } else { throw new UnsupportedAuditQueryTypeException(queryType); } return(undoQuery); }
public long[] GetMatchIndex(long row, ArrayRange range) { return(m_Comparison.GetMatchIndex(row, range)); }
public abstract long[] GetMatchIndex(ArrayRange indices, Operation.Matcher matcher);
LinkRequest IMergeAlgorithm.GetLink(Column sourceColumn, ArrayRange sourceIndices) { return(this.GetLink(sourceColumn, sourceIndices)); }
protected override long[] GetSortIndex(IComparer <DataT> comparer, ArrayRange indices, bool relativeIndex) { if (indices.array != null) { return(base.GetSortIndex(comparer, indices, relativeIndex)); } long count = indices.indexCount; DataT[] k = new DataT[count]; long firstChunkSubIndex = indices.directIndexFirst % m_Cache.m_DataSet.ChunkSize; long lastChunkSubIndex = indices.directIndexLast % m_Cache.m_DataSet.ChunkSize; long firstChunkIndex = indices.directIndexFirst / m_Cache.m_DataSet.ChunkSize; long lastChunkIndex = indices.directIndexLast / m_Cache.m_DataSet.ChunkSize; long firstChunkLength = m_Cache.m_DataSet.ChunkSize - firstChunkSubIndex; long lastChunkLength = lastChunkSubIndex; long firstFullChunk = firstChunkIndex + 1; long lastFullChunk = lastChunkIndex; long fullChunkCount = lastFullChunk - firstFullChunk; if (firstChunkLength > m_Cache.m_DataSet.DataCount) { firstChunkLength = m_Cache.m_DataSet.DataCount; lastChunkLength = 0; } //copy first chunk if (firstChunkLength > 0) { var c = m_Cache.GetChunk(firstChunkIndex); System.Array.Copy(c.m_Data, 0, k, 0, firstChunkLength); } //copy full chunks for (long i = 0; i < fullChunkCount; ++i) { long chunkIndex = i + firstFullChunk; long chunkRowFirst = chunkIndex * m_Cache.m_DataSet.ChunkSize; var c = m_Cache.GetChunk(chunkIndex); System.Array.Copy(c.m_Data, 0, k, chunkRowFirst - indices.directIndexFirst, m_Cache.m_DataSet.ChunkSize); } //copy last chunk if (lastChunkLength > 0) { long chunkRowFirst = lastChunkIndex * m_Cache.m_DataSet.ChunkSize; var c = m_Cache.GetChunk(lastChunkIndex); System.Array.Copy(c.m_Data, 0, k, chunkRowFirst - indices.directIndexFirst, lastChunkLength); } //create index array long[] index = new long[count]; if (relativeIndex) { for (long i = 0; i != count; ++i) { index[i] = i; k[i] = GetRowValue(i + indices.directIndexFirst); } } else { for (long i = 0; i != count; ++i) { index[i] = i + indices.directIndexFirst; k[i] = GetRowValue(i + indices.directIndexFirst); } } #if (PROFILER_DEBUG_TEST) //Test if data is good against a simple un-optimized query loop for (long i = 0; i != count; ++i) { var v = GetRowValue(i + indices.directIndexFirst); long c = k[i].CompareTo(v); UnityEngine.Debug.Assert(c == 0); } #endif System.Array.Sort(k, index, comparer); return(index); }
protected virtual LinkRequest GetLink(Column sourceColumn, ArrayRange sourceIndices) { return(null); }
public override long[] GetMatchIndex(ArrayRange rowRange, Operation.Operator operation, Operation.Expression expression, long expressionRowFirst, bool rowToRow) { if (expression.type != type) { return(base.GetMatchIndex(rowRange, operation, expression, expressionRowFirst, rowToRow)); } using (Profiling.GetMarker(Profiling.MarkerId.ColumnMatchQueryInt).Auto()) { Update(); Operation.TypedExpression <int> typedExpression = expression as Operation.TypedExpression <int>; long count = rowRange.indexCount; var matchedIndices = new List <long>(128); if (rowToRow) { for (long i = 0; i != count; ++i) { var lhs = m_Cache[rowRange[i]]; var rhs = typedExpression.GetValue(expressionRowFirst + i); if (Operation.Operation.Match(operation, lhs, rhs)) { matchedIndices.Add(rowRange[i]); } } } else { if (Operation.Operation.IsOperatorOneToMany(operation)) { for (int i = 0; i != count; ++i) { var leftValue = m_Cache[rowRange[i]]; if (Operation.Operation.Match(operation, leftValue, typedExpression, expressionRowFirst)) { matchedIndices.Add(rowRange[i]); } } } else { var valueRight = typedExpression.GetValue(expressionRowFirst); //Optimization for equal operation when querying on all data if (rowRange.array == null && operation == Operation.Operator.Equal) { //use the sorted index to trim down invalid values long[] sortedIndex = GetSortIndexAsc(); int lowerIndexIndex = LowerBoundIndex(sortedIndex, (int)rowRange.directIndexFirst, (int)rowRange.indexCount, valueRight); int upperIndexIndex = (int)rowRange.directIndexLast; for (int i = lowerIndexIndex; i < upperIndexIndex; ++i) { if (m_Cache[sortedIndex[i]] == valueRight) { matchedIndices.Add(sortedIndex[i]); } else { break; } } #if PROFILER_DEBUG_TEST { //Test to validate if optimization works int matchCount = 0; for (int i = 0; i != count; ++i) { var leftValue = m_Cache[rowRange[i]]; if (Operation.Operation.Match(operation, leftValue, valueRight)) { ++matchCount; if (matchedIndices.FindIndex(x => x == rowRange[i]) < 0) { UnityEngine.Debug.LogError("GetMatchIndex Optimization failure on index " + rowRange[i]); } } } if (matchCount != matchedIndices.Count) { UnityEngine.Debug.LogError("GetMatchIndex Optimization failure on match count " + matchCount + " != " + matchedIndices.Count); } } #endif } else { for (int i = 0; i != count; ++i) { var leftValue = m_Cache[rowRange[i]]; if (Operation.Operation.Match(operation, leftValue, valueRight)) { matchedIndices.Add(rowRange[i]); } } } } } var matchedIndicesArray = matchedIndices.ToArray(); #if MEMPROFILER_DEBUG_INFO Algorithm.DebugLog("GetMatchIndex : indexCount " + rowRange.indexCount + " op:" + Operation.Operation.OperatorToString(operation) + " Exp():" + expression.GetValueString(expressionRowFirst) + " expRowFirst:" + expressionRowFirst + " Column:" + this.GetDebugString(rowRange[0]) + " Expression:" + expression.GetDebugString(expressionRowFirst) + " Result Count:" + (matchedIndices != null ? matchedIndices.Length : 0)); #endif return(matchedIndicesArray); } }
protected abstract IComparable GroupTyped(ColumnTyped <DataT> sourceColumn, ArrayRange sourceIndices);
public override System.Collections.Generic.IEnumerable <DataOutT> VisitRows(ArrayRange indices) { for (long i = 0; i != indices.indexCount; ++i) { yield return(m_Transformer(m_Cache[indices[i]])); } }
protected override LinkRequest GetLink(Column sourceColumn, ArrayRange sourceIndices) { return(sourceColumn.GetRowLink(sourceIndices[0])); }
public static IEnumerable <T> AsEnumerable <T>(this ArrayRange <T> source) { return(new ArraySegment <T>(source.Array, 0, source.Count)); }
protected override IComparable GroupTyped(ColumnTyped <DataT> sourceColumn, ArrayRange sourceIndices) { return(math.Make(sourceIndices.Count)); }
public abstract long[] GetSortIndex(SortOrder order, ArrayRange indices, bool relativeIndex);