protected override void Binding()
{
base.Binding();
_refresh = new MvxUIRefreshControl();
var emptyDataSet = new EmptyDataSet(ContentView, ViewModel.RefreshCommand);
var source = new ContactsTableViewSource(TableView, ContactTableViewCell.Key, ContactTableViewCell.Key);
var set = this.CreateBindingSet <ContactsView, ContactsViewModel>();
set.Bind(emptyDataSet).For(StatesTargetBinding.Key).To(vm => vm.State);
set.Bind(source).To(vm => vm.Items);
set.Bind(source).For(s => s.GetContactsCommand).To(vm => vm.LoadNextPage);
set.Bind(source).For(v => v.SelectionChangedCommand).To(vm => vm.ItemClickCommand);
set.Bind(_refresh).For(r => r.IsRefreshing).To(vm => vm.IsRefreshing);
set.Bind(_refresh).For(r => r.RefreshCommand).To(vm => vm.RefreshCommand);
set.Apply();
TableView.Source = source;
TableView.RefreshControl = _refresh;
TableView.ReloadData();
}
} // getInformationSchema()
public virtual DataSet materializeInformationSchemaTable(Table table, List <SelectItem> selectItems)
{
String tableName = table.getName();
SelectItem[] columnSelectItems = MetaModelHelper.createSelectItems(table.getColumns());
SimpleDataSetHeader header = new SimpleDataSetHeader(columnSelectItems);
Table[] tables = getDefaultSchema().getTables(false);
List <Row> data = new List <Row>();
if ("tables".Equals(tableName))
{
// "tables" columns: name, type, num_columns, remarks
foreach (Table t in tables)
{
String typeString = null;
if (t.GetType() != null)
{
typeString = t.getType().ToString();
}
data.Add(new DefaultRow(header,
new Object[] { t.getName(), typeString, t.getColumnCount(), t.getRemarks() }));
}
}
else if ("columns".Equals(tableName))
{
// "columns" columns: name, type, native_type, size, nullable,
// indexed, table, remarks
foreach (Table t in tables)
{
foreach (Column c in t.getColumns())
{
String typeString = null;
if (t.GetType() != null)
{
typeString = c.getType().ToString();
}
data.Add(new DefaultRow(header, new Object[] { c.getName(), typeString, c.getNativeType(),
c.getColumnSize(), c.isNullable(), c.isIndexed(), t.getName(), c.getRemarks() }));
}
}
}
else if ("relationships".Equals(tableName))
{
// "relationships" columns: primary_table, primary_column,
// foreign_table, foreign_column
foreach (Relationship r in getDefaultSchema().getRelationships())
{
Column[] primaryColumns = r.getPrimaryColumns();
Column[] foreignColumns = r.getForeignColumns();
Table pTable = r.getPrimaryTable();
Table fTable = r.getForeignTable();
for (int i = 0; i < primaryColumns.Length; i++)
{
Column pColumn = primaryColumns[i];
Column fColumn = foreignColumns[i];
data.Add(new DefaultRow(header,
new Object[] { pTable.getName(), pColumn.getName(), fTable.getName(), fColumn.getName() }));
}
}
}
else
{
throw new ArgumentException("Cannot materialize non information_schema table: " + table);
}
DataSet dataSet;
if (data.IsEmpty())
{
dataSet = new EmptyDataSet(selectItems);
}
else
{
dataSet = new InMemoryDataSet(header, data);
}
// Handle column subset
DataSet selectionDataSet = MetaModelHelper.getSelection(selectItems, dataSet);
dataSet = selectionDataSet;
return(dataSet);
} // materializeInformationSchemaTable()
public StatesTargetBinding(EmptyDataSet view) : base(view)
{
}
} // getGrouped()
public static DataSet getGrouped(List <SelectItem> selectItems, DataSet dataSet, GroupByItem[] groupByItems)
{
DataSet result = dataSet;
if (groupByItems != null && groupByItems.Length > 0)
{
Dictionary <Row, Dictionary <SelectItem, List <Object> > > uniqueRows = new Dictionary <Row, Dictionary <SelectItem, List <Object> > >();
SelectItem[] groupBySelects = new SelectItem[groupByItems.Length];
for (int i = 0; i < groupBySelects.Length; i++)
{
groupBySelects[i] = groupByItems[i].getSelectItem();
}
DataSetHeader groupByHeader = new CachingDataSetHeader(groupBySelects);
// Creates a list of SelectItems that have aggregate functions
List <SelectItem> functionItems = getAggregateFunctionSelectItems(selectItems);
// Loop through the dataset and identify groups
while (dataSet.next())
{
Row row = dataSet.getRow();
// Subselect a row prototype with only the unique values that
// define the group
Row uniqueRow = row.getSubSelection(groupByHeader);
// function input is the values used for calculating aggregate
// functions in the group
Dictionary <SelectItem, List <Object> > functionInput;
if (!uniqueRows.ContainsKey(uniqueRow))
{
// If this group already exist, use an existing function
// input
functionInput = new Dictionary <SelectItem, List <Object> >();
foreach (SelectItem item in functionItems)
{
functionInput.Add(item, new List <Object>());
}
uniqueRows.Add(uniqueRow, functionInput);
}
else
{
// If this is a new group, create a new function input
functionInput = uniqueRows[uniqueRow];
}
// Loop through aggregate functions to check for validity
foreach (SelectItem item in functionItems)
{
List <Object> objects = functionInput[item];
Column column = item.getColumn();
if (column != null)
{
Object value = row.getValue(new SelectItem(column));
objects.Add(value);
}
else if (SelectItem.isCountAllItem(item))
{
// Just use the empty string, since COUNT(*) don't
// evaluate values (but null values should be prevented)
objects.Add("");
}
else
{
throw new ArgumentException("Expression function not supported: " + item);
}
}
}
dataSet.close();
List <Row> resultData = new List <Row>();
DataSetHeader resultHeader = new CachingDataSetHeader(selectItems);
int count = uniqueRows.Count;
// Loop through the groups to generate aggregates
foreach (KeyValuePair <Row, Dictionary <SelectItem, List <Object> > > key_value in uniqueRows)
{
Row row = key_value.Key;
Dictionary <SelectItem, List <Object> > functionInput = key_value.Value;
Object[] resultRow = new Object[selectItems.Count];
// Loop through select items to generate a row
int i = 0;
foreach (SelectItem item in selectItems)
{
int uniqueRowIndex = row.indexOf(item);
if (uniqueRowIndex != -1)
{
// If there's already a value for the select item in the
// row, keep it (it's one of the grouped by columns)
resultRow[i] = row.getValue(uniqueRowIndex);
}
else
{
// Use the function input to calculate the aggregate
// value
List <Object> objects = functionInput[item];
if (objects != null)
{
Object functionResult = item.getAggregateFunction().evaluate(objects.ToArray());
resultRow[i] = functionResult;
}
else
{
if (item.getAggregateFunction() != null)
{
logger.error("No function input found for SelectItem: {}", item);
}
}
}
i++;
}
resultData.Add(new DefaultRow(resultHeader, resultRow, null));
}
if (resultData.IsEmpty())
{
result = new EmptyDataSet(selectItems);
}
else
{
result = new InMemoryDataSet(resultHeader, resultData);
}
}
result = getSelection(selectItems, result);
return(result);
} // getGrouped()
