public void IndexCollectionScan <TT>(string memberName, TT[] values)
{
var p = new RowScanPlanItem(_journal, _tx);
p.AddContainsScan(Metadata.GetColumnByPropertyName(memberName), values);
_planHead = p;
}
public UnionPlanItem(IPlanItem left, IPlanItem right)
{
_left = left;
_right = right;
Timestamps = new DateRange(_left.Timestamps);
Timestamps.Union(_right.Timestamps);
}
public void Logical(ResultSetBuilder left, ResultSetBuilder right, ExpressionType op)
{
if (op == ExpressionType.And)
{
_planHead = OptimizeIntersect(left._planHead, right._planHead);
}
else if (op == ExpressionType.Or)
{
if (left._planHead is TimestampRangePlanItem &&
right._planHead is TimestampRangePlanItem)
{
_planHead = left._planHead;
_planHead.Timestamps.Union(right._planHead.Timestamps);
return;
}
if (left._planHead is RowScanPlanItem && right._planHead is RowScanPlanItem)
{
var rowScan1 = (RowScanPlanItem)left._planHead;
var rowScan2 = (RowScanPlanItem)right._planHead;
if (rowScan1.TryUnion(rowScan2))
{
_planHead = left.PlanItem;
return;
}
}
_planHead = new UnionPlanItem(left._planHead, right._planHead);
}
else
{
throw new NotImplementedException();
}
}
public void TakeLatestBy(string latestBySymbol)
{
var column = Metadata.GetColumnByPropertyName(latestBySymbol);
if (_planHead == null)
{
_planHead = CreateLastestByIdPlanItem(column);
}
else if (_planHead is TimestampRangePlanItem)
{
var newHead = CreateLastestByIdPlanItem(column);
newHead.Intersect(_planHead);
_planHead = newHead;
}
else
{
if (!AddLatestToColumnScan(_planHead, latestBySymbol))
{
var queryBySym = CreateLastestByIdPlanItem(column);
_planHead = new IntersectPlanItem(queryBySym, _planHead);
}
else
{
_planHead = RebuildWithLatest(_planHead, column);
}
}
}
public void ColumnLambdaScan <T>(IColumnMetadata column, Func <T, bool> lambda)
{
var planItem = new RowScanPlanItem(_journal, _tx);
planItem.AddLambdaScan(column, lambda);
_planHead = planItem;
}
public void ColumnScan <T>(IColumnMetadata column, T literal)
{
var planItem = new RowScanPlanItem(_journal, _tx);
planItem.AddContainsScan(column, literal);
_planHead = planItem;
}
public IntersectPlanItem(IPlanItem left, IPlanItem right)
{
_left = left;
_right = right;
Timestamps = new DateRange(left.Timestamps);
Timestamps.Intersect(right.Timestamps);
left.Intersect(right);
right.Intersect(left);
}
private IPlanItem RebuildWithLatest(IPlanItem planHead, IColumnMetadata latestByColumn)
{
var column = Metadata.GetColumnByPropertyName(latestByColumn.PropertyName);
var intersc = planHead as IntersectPlanItem;
if (intersc != null)
{
if (AddLatestToColumnScan(intersc.Left, latestByColumn.PropertyName))
{
return
(new IntersectPlanItem(
RebuildWithLatest(intersc.Left, latestByColumn),
intersc.Right));
}
if (AddLatestToColumnScan(intersc.Right, latestByColumn.PropertyName))
{
return(new IntersectPlanItem(intersc.Left,
RebuildWithLatest(intersc.Right, latestByColumn)));
}
throw new InvalidOperationException("One of the Intersect path " +
"supposed to be reduced with" +
" Latest by symbol plan");
}
var union = planHead as UnionPlanItem;
if (union != null)
{
return(new UnionPlanItem(
RebuildWithLatest(union.Left, latestByColumn),
RebuildWithLatest(union.Right, latestByColumn)));
}
var scan = planHead as IColumnScanPlanItemCore;
if (scan != null)
{
if (scan.CanTranformLastestByIdPlanItem(latestByColumn))
{
scan.ApplyLastestByIdPlanItem(latestByColumn);
return(planHead);
}
}
var timestmp = planHead as TimestampRangePlanItem;
if (timestmp != null)
{
var newItem = CreateLastestByIdPlanItem(column);
newItem.Timestamps.Intersect(timestmp.Timestamps);
return(newItem);
}
throw new NotSupportedException("Plan type is not supported " + planHead.GetType());
}
public QueryRowsResult Build()
{
if (_planHead != null)
{
_planHead = OptimizePlan(_planHead);
}
else
{
_planHead = new TimestampRangePlanItem(DateInterval.Any);
}
IEnumerable <long> rowIDs = _planHead.Execute(_journal, _tx, GetTimestampOrder());
return(BindPostResult(rowIDs));
}
public void ColumnNotNullScan(IColumnMetadata column)
{
var planItem = new RowScanPlanItem(_journal, _tx);
_planHead = planItem;
if (!Metadata.IsNullColumnID.HasValue || !column.Nullable || column.NullIndex < 0)
{
return;
}
var isNullColumn = Metadata.GetColumnByID(Metadata.IsNullColumnID.Value);
Func <ByteArray, bool> lambda = ba => !ba.IsSet(column.NullIndex);
planItem.AddLambdaScan(isNullColumn, lambda);
}
public void IndexCollectionScan(string memberName, IEnumerable values, Expression exp)
{
var p = new RowScanPlanItem(_journal, _tx);
var column = Metadata.GetColumnByPropertyName(memberName);
switch (column.DataType.ColumnType)
{
case EFieldType.Byte:
p.AddContainsScan(column, ToIList <byte>(values));
break;
case EFieldType.Bool:
p.AddContainsScan(column, ToIList <bool>(values));
break;
case EFieldType.Int16:
p.AddContainsScan(column, ToIList <short>(values));
break;
case EFieldType.Int32:
p.AddContainsScan(column, ToIList <int>(values));
break;
case EFieldType.Int64:
p.AddContainsScan(column, ToIList <long>(values));
break;
case EFieldType.Double:
p.AddContainsScan(column, ToIList <double>(values));
break;
case EFieldType.Symbol:
case EFieldType.String:
p.AddContainsScan(column, ToIList <string>(values));
break;
case EFieldType.DateTime:
case EFieldType.DateTimeEpochMs:
p.AddContainsScan(column, ToIList <DateTime>(values));
break;
default:
throw QueryExceptionExtensions.ExpressionNotSupported(
string.Format("Column of type {0} cannot be bound to Contains expressions", column.DataType.ColumnType), exp);
}
_planHead = p;
}
private bool AddLatestToColumnScan(IPlanItem planHead, string latestBySymbol)
{
var intersc = planHead as IntersectPlanItem;
if (intersc != null)
{
return(AddLatestToColumnScan(intersc.Left, latestBySymbol) ||
AddLatestToColumnScan(intersc.Right, latestBySymbol));
}
var union = planHead as UnionPlanItem;
if (union != null)
{
return(AddLatestToColumnScan(union.Left, latestBySymbol) &&
AddLatestToColumnScan(union.Right, latestBySymbol));
}
var scan = planHead as IColumnScanPlanItemCore;
if (scan != null)
{
var col = Metadata.GetColumnByPropertyName(latestBySymbol);
if (scan.CanTranformLastestByIdPlanItem(col))
{
return(true);
}
return(false);
}
var timestmp = planHead as TimestampRangePlanItem;
if (timestmp != null)
{
return(true);
}
throw new NotSupportedException("Plan type is not supported " + planHead.GetType());
}
private static IPlanItem OptimizeIntersect(IPlanItem left, IPlanItem right)
{
if (right is TimestampRangePlanItem)
{
left.Intersect(right);
return(left);
}
if (left is TimestampRangePlanItem)
{
right.Intersect(left);
return(right);
}
if (left is RowScanPlanItem && right is RowScanPlanItem)
{
var rowScan1 = (RowScanPlanItem)left;
var rowScan2 = (RowScanPlanItem)right;
if (rowScan1.TryIntersect(rowScan2))
{
return(left);
}
}
return(new IntersectPlanItem(left, right));
}
public ResultSetBuilder(IJournalCore journal, IReadTransactionContext tx)
{
_journal = journal;
_tx = tx;
_planHead = new TimestampRangePlanItem(DateInterval.Any);
}
public void ApplyFilter(ResultSetBuilder filter)
{
_planHead = OptimizeIntersect(_planHead, filter._planHead);
}
private IPlanItem OptimizePlan(IPlanItem planHead)
{
return(planHead);
}
public LastestByPlanItem(IColumnMetadata column, IPlanItem child = null)
{
_column = column;
_child = child;
Timestamps = new DateRange();
}
public void TimestampInterval(DateInterval filterInterval)
{
_planHead = new TimestampRangePlanItem(filterInterval);
}
public void Intersect(IPlanItem restriction)
{
Timestamps.Intersect(restriction.Timestamps);
_left.Intersect(restriction);
_right.Intersect(restriction);
}
public LastestByPlanItem(IColumnMetadata column, T[] literals, IPlanItem child = null)
: this(column, child)
{
_keys = literals;
}
