public void NewVirtualTableFromOneTableSource()
{
var table = new VirtualTable(ObjectName.Parse("#table#"), left, new long[] { 1 });
Assert.Equal(1, table.RowCount);
Assert.Equal(2, table.TableInfo.Columns.Count);
}
public async Task LeftOuterTable()
{
var leftRows = left.Select(x => x.Number);
var rightRows = right.Select(x => x.Number);
var v1 = new VirtualTable(new[] { left, right }, new[] { leftRows, rightRows });
var result = v1.Outer(left);
Assert.NotNull(result);
Assert.Equal(4, result.RowCount);
Assert.Equal(4, result.TableInfo.Columns.Count);
// the outher right join has placed the left table on top
// while the previous merge had the columns at the beginning
// +--------+--------+--------+--------+
// | tab1.a | tab1.b | tab2.a | tab2.b |
// +-----------------------------------+
//
var value1 = await result.GetValueAsync(1, 0);
var value2 = await result.GetValueAsync(1, 1);
Assert.Equal(SqlObject.Integer(54), value1);
Assert.Equal(SqlObject.Boolean(null), value2);
}
public async Task GetLastValueOfOneTableSource()
{
var table = new VirtualTable(ObjectName.Parse("#table#"), left, new long[] { 1 });
var value = await table.GetValueAsync(0, 1);
Assert.NotNull(value);
Assert.IsType <SqlBooleanType>(value.Type);
}
protected override void ExecuteStatement(ExecutionContext context)
{
if (!context.Request.Context.CursorExists(CursorName))
throw new StatementException(String.Format("The cursor '{0}' was not found in the current context.", CursorName));
var cursor = context.Request.Context.FindCursor(CursorName);
if (cursor == null)
throw new StatementException(String.Format("The cursor '{0}' was not found in the current context.", CursorName));
if (cursor.Status == CursorStatus.Closed)
throw new StatementException(String.Format("The cursor '{0}' was already closed.", CursorName));
int offset = -1;
if (OffsetExpression != null)
offset = OffsetExpression.EvaluateToConstant(context.Request, null);
var row = cursor.Fetch(Direction, offset);
if (row != null) {
var result = new VirtualTable(row.Table, new List<int> {row.RowId.RowNumber});
context.SetResult(result);
}
}
public static ITable SelectRange(this ITable thisTable, ObjectName columnName, IndexRange[] ranges)
{
// If this table is empty then there is no range to select so
// trivially return this object.
if (thisTable.RowCount == 0)
return thisTable;
// Are we selecting a black or null range?
if (ranges == null || ranges.Length == 0)
// Yes, so return an empty table
return thisTable.EmptySelect();
// Are we selecting the entire range?
if (ranges.Length == 1 &&
ranges[0].Equals(IndexRange.FullRange))
// Yes, so return this table.
return thisTable;
// Must be a non-trivial range selection.
// Find the column index of the column selected
int column = thisTable.IndexOfColumn(columnName);
if (column == -1) {
throw new Exception(
"Unable to find the column given to select the range of: " +
columnName.Name);
}
// Select the range
var rows = thisTable.SelectRowsRange(column, ranges);
// Make a new table with the range selected
var result = new VirtualTable(thisTable, rows.ToArray());
// We know the new set is ordered by the column.
result.SortColumn = column;
return result;
}
public static ITable Join(this ITable table, ITable otherTable, bool quick)
{
ITable outTable;
if (quick) {
// This implementation doesn't materialize the join
outTable = new NaturallyJoinedTable(table, otherTable);
} else {
var tabs = new [] { table, otherTable};
var rowSets = new IList<int>[2];
// Optimized trivial case, if either table has zero rows then result of
// join will contain zero rows also.
if (table.RowCount == 0 || otherTable.RowCount == 0) {
rowSets[0] = new List<int>(0);
rowSets[1] = new List<int>(0);
} else {
// The natural join algorithm.
List<int> thisRowSet = new List<int>();
List<int> tableRowSet = new List<int>();
// Get the set of all rows in the given table.
var tableSelectedSet = otherTable.Select(x => x.RowId.RowNumber).ToList();
int tableSelectedSetSize = tableSelectedSet.Count;
// Join with the set of rows in this table.
var e = table.GetEnumerator();
while (e.MoveNext()) {
int rowIndex = e.Current.RowId.RowNumber;
for (int i = 0; i < tableSelectedSetSize; ++i) {
thisRowSet.Add(rowIndex);
}
tableRowSet.AddRange(tableSelectedSet);
}
// The row sets we are joining from each table.
rowSets[0] = thisRowSet;
rowSets[1] = tableRowSet;
}
// Create the new VirtualTable with the joined tables.
outTable = new VirtualTable(tabs, rowSets);
}
return outTable;
}
public static ITable ExhaustiveSelect(this ITable table, IRequest context, SqlExpression expression)
{
var result = table;
// Exit early if there's nothing in the table to select from
int rowCount = table.RowCount;
if (rowCount > 0) {
var tableResolver = table.GetVariableResolver();
List<int> selectedSet = new List<int>(rowCount);
foreach (var row in table) {
int rowIndex = row.RowId.RowNumber;
var rowResolver = tableResolver.ForRow(rowIndex);
// Resolve expression into a constant.
var exp = expression.Evaluate(context, rowResolver);
if (exp.ExpressionType != SqlExpressionType.Constant)
throw new NotSupportedException();
var value = ((SqlConstantExpression) exp).Value;
// If resolved to true then include in the selected set.
if (!value.IsNull && value.Type is BooleanType &&
value == true) {
selectedSet.Add(rowIndex);
}
}
result = new VirtualTable(table, selectedSet); ;
}
return result;
}
