public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
connection.Run(Query.DbCreate("test"));
connection.Run(Query.Db("test").TableCreate("table"));
testTable = Query.Db("test").Table <TestObjectWithDictionary>("table");
}
public IndexCreateQuery(ITableQuery <TTable> tableTerm, string indexName, Expression <Func <TTable, TIndexExpression> > indexExpression, bool multiIndex)
{
this.tableTerm = tableTerm;
this.indexName = indexName;
this.indexExpression = indexExpression;
this.multiIndex = multiIndex;
}
public static MinAggregateIndexQuery <TRecord, TIndexType> Min <TRecord, TIndexType>(
this ITableQuery <TRecord> tableQuery,
string indexName
)
{
return(new MinAggregateIndexQuery <TRecord, TIndexType>(tableQuery, indexName));
}
public static MaxAggregateIndexQuery <TRecord, TIndexType> Max <TRecord, TIndexType>(
this ITableQuery <TRecord> tableQuery,
IIndex <TRecord, TIndexType> index
)
{
return(new MaxAggregateIndexQuery <TRecord, TIndexType>(tableQuery, index.Name));
}
internal QueryTranslator(ITableQuery <T> query)
{
Arguments.IsNotNull(query, nameof(query));
Query = query;
QueryDescription = new(Query.RemoteTable.TableName) { IncludeTotalCount = query.RequestTotalCount };
}
public static GroupByIndexQuery <TRecord, TIndexType> Group <TRecord, TIndexType>(
// Can only use indexName on Group on a TABLE, not any arbitrary sequence
this ITableQuery <TRecord> table,
string indexName
)
{
return(new GroupByIndexQuery <TRecord, TIndexType>(table, indexName));
}
public static GroupByIndexQuery <TRecord, TIndexType> Group <TRecord, TIndexType>(
// Can only use indexName on Group on a TABLE, not any arbitrary sequence
this ITableQuery <TRecord> table,
IIndex <TRecord, TIndexType> index
)
{
return(table.Group <TRecord, TIndexType>(index.Name));
}
public virtual void SetUp()
{
connection.RunAsync(Query.DbCreate("test")).Wait();
connection.RunAsync(Query.Db("test").TableCreate("table")).Wait();
testTable = Query.Db("test").Table<TestObject>("table");
testTable2 = Query.Db("test").Table<TestObject2>("table");
testTable3 = Query.Db("test").Table<TestObject3>("table");
}
public virtual void SetUp()
{
connection.RunAsync(Query.DbCreate("test")).Wait();
connection.RunAsync(Query.Db("test").TableCreate("table")).Wait();
testTable = Query.Db("test").Table <TestObject>("table");
testTable2 = Query.Db("test").Table <TestObject2>("table");
testTable3 = Query.Db("test").Table <TestObject3>("table");
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
connection.RunAsync(Query.DbCreate("test")).Wait();
connection.RunAsync(Query.Db("test").TableCreate("table")).Wait();
testTable = Query.Db("test").Table<TestObject>("table");
connection.Run(testTable.IndexCreate("index1", o => o.Name));
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
connection.RunAsync(Query.DbCreate("test")).Wait();
connection.RunAsync(Query.Db("test").TableCreate("table")).Wait();
testTable = Query.Db("test").Table <TestObject>("table");
connection.Run(testTable.IndexCreate("index1", o => o.Name));
}
public UserRepository(string clusterName, string dbName, string tableName)
{
if (!string.IsNullOrEmpty(clusterName) && !string.IsNullOrEmpty(dbName) && !string.IsNullOrEmpty(tableName))
{
_connectionFactory = ConfigurationAssembler.CreateConnectionFactory(clusterName);
_db = Query.Db(dbName);
_table = _db.Table<User>(tableName);
}
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
connection.RunAsync(Query.DbCreate("test")).Wait();
connection.RunAsync(Query.Db("test").TableCreate("table")).Wait();
testTable = Query.Db("test").Table <TestObject>("table");
connection.Run(testTable.IndexCreate("index1", o => o.Name));
connection.Run(testTable.IndexWait("index1")).ToArray(); // ToArray ensures that the IEnumerable is actually evaluated completely and the wait is completed
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
connection.RunAsync(Query.DbCreate("test")).Wait();
connection.RunAsync(Query.Db("test").TableCreate("table")).Wait();
testTable = Query.Db("test").Table<TestObject>("table");
nameIndex = testTable.IndexDefine("index1", o => o.Name);
connection.Run(nameIndex.IndexCreate());
connection.Run(nameIndex.IndexWait()).ToArray(); // ToArray ensures that the IEnumerable is actually evaluated completely and the wait is completed
}
/// <summary>
/// Executes a query on a table.
/// </summary>
/// <param name="tableQuery">
/// A <see cref="ITableQuery" /> representing the query to execute.
/// </param>
/// <returns>
/// An enumerable collection of <see cref="T:Microsoft.WindowsAzure.Storage.Table.DynamicTableEntity" /> objects, representing table entities returned by the query.
/// </returns>
public IEnumerable <DynamicTableEntity> ExecuteQuery(ITableQuery tableQuery)
{
var query = new TableQuery
{
FilterString = tableQuery.FilterString,
SelectColumns = tableQuery.SelectColumns,
TakeCount = tableQuery.TakeCount
};
return(_cloudTable.ExecuteQuery(query));
}
/// <summary>
/// Executes a query on a table asynchronously.
/// </summary>
/// <param name="tableQuery">Table query.</param>
/// <param name="cancellationToken">Cancellation token.</param>
/// <returns>
/// An enumerable collection of <see cref="T:Microsoft.WindowsAzure.Storage.Table.DynamicTableEntity" /> objects, representing table entities returned by the query.
/// </returns>
public Task <IEnumerable <DynamicTableEntity> > ExecuteQueryAsync(ITableQuery tableQuery, CancellationToken cancellationToken)
{
var query = new TableQuery
{
FilterString = tableQuery.FilterString,
SelectColumns = tableQuery.SelectColumns,
TakeCount = tableQuery.TakeCount
};
return(_cloudTable.ExecuteQueryAsync(query, cancellationToken));
}
/// <summary>
/// Executes a query on a table asynchronously.
/// </summary>
/// <param name="tableQuery">Table query.</param>
/// <param name="cancellationToken">Cancellation token.</param>
/// <returns>
/// An enumerable collection of <see cref="T:Microsoft.WindowsAzure.Storage.Table.DynamicTableEntity" /> objects, representing table entities returned by the query.
/// </returns>
public Task<IEnumerable<DynamicTableEntity>> ExecuteQueryAsync(ITableQuery tableQuery, CancellationToken cancellationToken)
{
var query = new TableQuery
{
FilterString = tableQuery.FilterString,
SelectColumns = tableQuery.SelectColumns,
TakeCount = tableQuery.TakeCount
};
return _cloudTable.ExecuteQueryAsync(query, cancellationToken);
}
/// <summary>
/// Executes a query on a table.
/// </summary>
/// <param name="tableQuery">
/// A <see cref="ITableQuery" /> representing the query to execute.
/// </param>
/// <returns>
/// An enumerable collection of <see cref="T:Microsoft.WindowsAzure.Storage.Table.DynamicTableEntity" /> objects, representing table entities returned by the query.
/// </returns>
public IEnumerable<DynamicTableEntity> ExecuteQuery(ITableQuery tableQuery)
{
var query = new TableQuery
{
FilterString = tableQuery.FilterString,
SelectColumns = tableQuery.SelectColumns,
TakeCount = tableQuery.TakeCount
};
return _cloudTable.ExecuteQuery(query);
}
/// <summary>
/// Gets the next page of items from the list. If the <c>nextLink</c> is set, use that for
/// the query; otherwise use the <c>query</c>
/// </summary>
/// <param name="query">The initial query.</param>
/// <param name="nextLink">The next link.</param>
/// <param name="cancellationToken">A <see cref="CancellationToken"/> to observe.</param>
/// <returns>A task that returns a page of items when complete.</returns>
private async Task <Page <U> > GetNextPageAsync <U>(ITableQuery <U> query, string nextLink, CancellationToken cancellationToken = default)
{
var page = await base.GetNextPageAsync(((TableQuery <U>)query).ToODataString(true), nextLink, cancellationToken).ConfigureAwait(false);
return(new Page <U>
{
Count = page.Count,
Items = page.Items.Select(m => Serializer.Deserialize <U>(m)).ToArray(),
NextLink = page.NextLink
});
}
public virtual void SetUp()
{
testTable = Query.Db("test").Table <TestObject>("table");
connection.RunAsync(testTable.Insert(new TestObject[] {
new TestObject()
{
Name = "1", SomeNumber = 1
},
new TestObject()
{
Name = "1", SomeNumber = 1
},
new TestObject()
{
Name = "2", SomeNumber = 2
},
new TestObject()
{
Name = "2", SomeNumber = 200
},
new TestObject()
{
Name = "2", SomeNumber = 2
},
new TestObject()
{
Name = "3", SomeNumber = 3
},
new TestObject()
{
Name = "3", SomeNumber = 3
},
new TestObject()
{
Name = "4", SomeNumber = 4
},
new TestObject()
{
Name = "5", SomeNumber = 5
},
new TestObject()
{
Name = "6", SomeNumber = 6
},
new TestObject()
{
Name = "6", SomeNumber = 6
},
new TestObject()
{
Name = "7", SomeNumber = 7
},
})).Wait();
}
/// <summary>
/// Executes the current <paramref name="query"/>
/// and enumerates it to a list.
/// </summary>
/// <remarks>
/// Warning. This method could cause serious performance
/// implications and should only be used for limited sets of data.
/// </remarks>
public static ICollection <T> WithChildren <T>(this ITableQuery <T> query, params string[] relationshipPropertyNames) where T : new()
{
List <T> results = query.ToList();
// ReSharper disable once CompareNonConstrainedGenericWithNull
if (results.Count == 0)
{
return(results);
}
query.Connection.SetChildren(results);
return(results);
}
/// <summary>Initializes a new instance of the <see cref="TableQueryAsync{T}" /> class.</summary>
/// <param name="innerQuery">The inner query.</param>
/// <param name="db">Database instance.</param>
/// <param name="taskScheduler">
/// If null this parameter will be TaskScheduler.Default (evaluated
/// when used in each method, not in ctor)
/// </param>
/// <param name="taskCreationOptions">Defaults to DenyChildAttach</param>
/// <exception cref="System.ArgumentNullException">innerQuery is NULL.</exception>
public TableQueryAsync(
ITableQuery <T> innerQuery, IDatabase db, TaskScheduler taskScheduler = null,
TaskCreationOptions taskCreationOptions = TaskCreationOptions.None)
{
if (innerQuery == null)
{
throw new ArgumentNullException("innerQuery");
}
_innerQuery = innerQuery;
_db = db;
_taskScheduler = taskScheduler;
_taskCreationOptions = taskCreationOptions;
}
private void ValidateQuery <T>(IQueryable <T> query)
{
ITableQuery tableQuery = query as ITableQuery;
if (tableQuery == null)
{
throw new ArgumentException("Query is not an NMemory query.", "query");
}
if (tableQuery.Database != this.Database)
{
throw new ArgumentException("Query does not belong to this database.", "query");
}
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
connection.RunAsync(Query.DbCreate("test")).Wait();
connection.RunAsync(Query.Db("test").TableCreate("table")).Wait();
testTable = Query.Db("test").Table<TestObject>("table");
// Insert more than 1000 objects to test the enumerable loading additional chunks of the sequence
var objectList = new List<TestObject>();
for (int i = 0; i < 1005; i++)
objectList.Add(new TestObject() { Name = "Object #" + i });
connection.RunAsync(testTable.Insert(objectList)).Wait();
}
/// <summary>
/// Construct a sink posting to the specified database.
/// </summary>
/// <param name="connectionFactory">The connection factory for connecting to RethinkDB.</param>
/// <param name="batchSizeLimit">The maximum number of events to post in a single batch.</param>
/// <param name="period">The time to wait between checking for event batches.</param>
/// <param name="databaseName">Name of the RethinkDB database to use for the log.</param>
/// <param name="tableName">Name of the RethinkDB collection to use for the log. Default is "log".</param>
public RethinkDBSink(IConnectionFactory connectionFactory, string databaseName, string tableName, int batchSizeLimit, TimeSpan period)
: base(batchSizeLimit, period)
{
if (connectionFactory == null)
{
throw new ArgumentNullException("connectionFactory");
}
_connectionFactory = connectionFactory;
_db = Query.Db(databaseName);
_table = _db.Table <RethinkDBLogEvent>(tableName);
EnsureDbCreated(databaseName, tableName);
}
ITableQuery <TResult> ITableQuery <T> .Join <TInner, TKey, TResult>(
ITableQuery <TInner> inner, Expression <Func <T, TKey> > outerKeySelector,
Expression <Func <TInner, TKey> > innerKeySelector,
Expression <Func <T, TInner, TResult> > resultSelector)
{
return(new TableQueryBridge <TResult>(
_sqlitePlatform, Connection, Connection.GetMapping(typeof(TResult)))
{
_joinOuter = this,
_joinOuterKeySelector = outerKeySelector,
_joinInner = inner as TableQueryBridge <TInner>,
_joinInnerKeySelector = innerKeySelector,
_joinSelector = resultSelector
});
}
/// <summary>
/// Runs a query on all routines.
/// </summary>
public void RunQueryAll(ITableQuery inQuery, ITableOperation inOperation)
{
int totalLeft = m_ActiveCount;
int currentNode = m_ActiveHead;
while (currentNode != -1 && totalLeft-- > 0)
{
Entry e = m_Entries[currentNode];
currentNode = e.NextIndex;
if (inQuery.Validate(e.Fiber))
{
inOperation.Execute(e.Fiber);
}
}
}
/// <summary>
/// Runs a query and returns the first routine to pass.
/// </summary>
public Routine RunQueryFirst(ITableQuery inQuery, ITableOperation inOperation)
{
int totalLeft = m_ActiveCount;
int currentNode = m_ActiveHead;
while (currentNode != -1 && totalLeft-- > 0)
{
Entry e = m_Entries[currentNode];
currentNode = e.NextIndex;
if (inQuery.Validate(e.Fiber))
{
inOperation.Execute(e.Fiber);
return(e.Fiber.GetHandle());
}
}
return(Routine.Null);
}
/// <summary>
/// Gets all the items from the list of items returned.
/// </summary>
/// <returns></returns>
private async Task <List <ClientMovie> > GetAllItems(ITableQuery <ClientMovie> query = null, IOfflineTable <ClientMovie> table = null, long?nItems = null)
{
table ??= base.table;
query ??= table.CreateQuery();
List <ClientMovie> items = new();
var pageable = table.GetAsyncItems(query) as AsyncPageable <ClientMovie>;
await foreach (var item in pageable)
{
if (nItems != null)
{
Assert.Equal(nItems !, pageable.Count);
}
items.Add(item);
}
return(items);
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
connection.RunAsync(Query.DbCreate("test")).Wait();
connection.RunAsync(Query.Db("test").TableCreate("table1")).Wait();
connection.RunAsync(Query.Db("test").TableCreate("table2")).Wait();
testTable = Query.Db("test").Table <TestObject>("table1");
anotherTestTable = Query.Db("test").Table <AnotherTestObject>("table2");
firstNameIndex = anotherTestTable.IndexDefine("index1", o => o.FirstName);
connection.Run(firstNameIndex.IndexCreate());
connection.Run(firstNameIndex.IndexWait());
tagsIndex = testTable.IndexDefineMulti("indexTags", o => o.Tags);
connection.Run(tagsIndex.IndexCreate());
connection.Run(tagsIndex.IndexWait());
}
public virtual void SetUp()
{
testTable = Query.Db("test").Table<TestObject>("table");
connection.RunAsync(testTable.Insert(new TestObject[] {
new TestObject() { Name = "1", SomeNumber = 1 },
new TestObject() { Name = "1", SomeNumber = 1 },
new TestObject() { Name = "2", SomeNumber = 2 },
new TestObject() { Name = "2", SomeNumber = 200 },
new TestObject() { Name = "2", SomeNumber = 2 },
new TestObject() { Name = "3", SomeNumber = 3 },
new TestObject() { Name = "3", SomeNumber = 3 },
new TestObject() { Name = "4", SomeNumber = 4 },
new TestObject() { Name = "5", SomeNumber = 5 },
new TestObject() { Name = "6", SomeNumber = 6 },
new TestObject() { Name = "6", SomeNumber = 6 },
new TestObject() { Name = "7", SomeNumber = 7 },
})).Wait();
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
connection.RunAsync(Query.DbCreate("test")).Wait();
connection.RunAsync(Query.Db("test").TableCreate("table1")).Wait();
connection.RunAsync(Query.Db("test").TableCreate("table2")).Wait();
testTable = Query.Db("test").Table<TestObject>("table1");
anotherTestTable = Query.Db("test").Table<AnotherTestObject>("table2");
firstNameIndex = anotherTestTable.IndexDefine("index1", o => o.FirstName);
connection.Run(firstNameIndex.IndexCreate());
connection.Run(firstNameIndex.IndexWait()).ToArray(); // ToArray ensures that the IEnumerable is actually evaluated completely and the wait is completed
tagsIndex = testTable.IndexDefineMulti("indexTags", o => o.Tags);
connection.Run(tagsIndex.IndexCreate());
connection.Run(tagsIndex.IndexWait()).ToArray(); // ToArray ensures that the IEnumerable is actually evaluated completely and the wait is completed
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
connection.RunAsync(Query.DbCreate("test")).Wait();
connection.RunAsync(Query.Db("test").TableCreate("table1")).Wait();
connection.RunAsync(Query.Db("test").TableCreate("table2")).Wait();
testTable = Query.Db("test").Table <TestObject>("table1");
anotherTestTable = Query.Db("test").Table <AnotherTestObject>("table2");
firstNameIndex = anotherTestTable.IndexDefine("index1", o => o.FirstName);
connection.Run(firstNameIndex.IndexCreate());
connection.Run(firstNameIndex.IndexWait()).ToArray(); // ToArray ensures that the IEnumerable is actually evaluated completely and the wait is completed
tagsIndex = testTable.IndexDefineMulti("indexTags", o => o.Tags);
connection.Run(tagsIndex.IndexCreate());
connection.Run(tagsIndex.IndexWait()).ToArray(); // ToArray ensures that the IEnumerable is actually evaluated completely and the wait is completed
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
connection.RunAsync(Query.DbCreate("test")).Wait();
connection.RunAsync(Query.Db("test").TableCreate("table1")).Wait();
connection.RunAsync(Query.Db("test").TableCreate("table2")).Wait();
testTable = Query.Db("test").Table<TestObject>("table1");
anotherTestTable = Query.Db("test").Table<AnotherTestObject>("table2");
firstNameIndex = anotherTestTable.IndexDefine("index1", o => o.FirstName);
connection.Run(firstNameIndex.IndexCreate());
connection.Run(firstNameIndex.IndexWait());
tagsIndex = testTable.IndexDefineMulti("indexTags", o => o.Tags);
connection.Run(tagsIndex.IndexCreate());
connection.Run(tagsIndex.IndexWait());
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
connection.RunAsync(Query.DbCreate("test")).Wait();
connection.RunAsync(Query.Db("test").TableCreate("table")).Wait();
testTable = Query.Db("test").Table <TestObject>("table");
// Insert more than 1000 objects to test the enumerable loading additional chunks of the sequence
var objectList = new List <TestObject>();
for (int i = 0; i < 1005; i++)
{
objectList.Add(new TestObject()
{
Name = "Object #" + i
});
}
connection.RunAsync(testTable.Insert(objectList)).Wait();
}
public TableView(ITableQuery query, string name, IEnumerable<IColumn> columns, int throttleTime, IConstituentRowRepository currentRows)
{
#region Guards
if (query == null) throw new ArgumentNullException("query", "query cannot be null");
if (string.IsNullOrEmpty(name)) throw new ArgumentNullException("name", "name cannot be null or empty");
#endregion
TableQuery = query;
Name = name;
this.throttleTime = throttleTime;
Columns = new ObservableCollection<IColumn>();
((ObservableCollection<IColumn>)Columns).CollectionChanged += OnColumnsChanged;
if (columns != null)
foreach (var column in columns)
Columns.Add(column);
Data = new RowBinding(Columns, currentRows.AttachView(this));
}
/// <summary>
/// Runs a query on all routines.
/// </summary>
public void RunQueryAll(ITableQuery inQuery, ITableOperation inOperation, ref ICollection <Routine> ioRoutines)
{
int totalLeft = m_ActiveCount;
int currentNode = m_ActiveHead;
while (currentNode != -1 && totalLeft-- > 0)
{
Entry e = m_Entries[currentNode];
currentNode = e.NextIndex;
if (inQuery.Validate(e.Fiber))
{
inOperation.Execute(e.Fiber);
if (ioRoutines == null)
{
ioRoutines = new List <Routine>();
}
ioRoutines.Add(e.Fiber.GetHandle());
}
}
}
public static ICompoundIndex <TRecord, T1, T2, T3> IndexDefine <TRecord, T1, T2, T3>(this ITableQuery <TRecord> table, string name,
Expression <Func <TRecord, T1> > indexAccessor1,
Expression <Func <TRecord, T2> > indexAccessor2,
Expression <Func <TRecord, T3> > indexAccessor3)
{
return(new CompoundIndex <TRecord, T1, T2, T3>(table, name, indexAccessor1, indexAccessor2, indexAccessor3));
}
public static IndexDropQuery <T> IndexDrop <T>(this ITableQuery <T> target, string indexName)
{
return(new IndexDropQuery <T>(target, indexName));
}
public static IIndex <TRecord, TIndex> IndexDefine <TRecord, TIndex>(this ITableQuery <TRecord> table, string name, Expression <Func <TRecord, TIndex> > indexAccessor)
{
return(new Index <TRecord, TIndex>(table, name, indexAccessor));
}
public static IndexListQuery <T> IndexList <T>(this ITableQuery <T> target)
{
return(new IndexListQuery <T>(target));
}
public virtual void SetUp()
{
testTable = Query.Db("test").Table<TestObject>("table");
DoInsert().Wait();
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
connection.Run(Query.DbCreate("test"));
connection.Run(Query.Db("test").TableCreate("table"));
testTable = Query.Db("test").Table<TestObject>("table");
connection.Run(testTable.Insert(new TestObject[]
{
new TestObject() { Name = "1", SomeNumber = 1 },
new TestObject() { Name = "1", SomeNumber = 1 },
new TestObject() { Name = "2", SomeNumber = 2, Tags = new string[] { "A", "B" } },
new TestObject() { Name = "2", SomeNumber = 200 },
new TestObject() { Name = "2", SomeNumber = 2, Tags = new string[] { "A", "C" } },
new TestObject() { Name = "3", SomeNumber = 3 },
new TestObject() { Name = "3", SomeNumber = 3 },
new TestObject() { Name = "4", SomeNumber = 4 },
new TestObject() { Name = "5", SomeNumber = 5 },
new TestObject() { Name = "6", SomeNumber = 6 },
new TestObject() { Name = "6", SomeNumber = 6 },
new TestObject() { Name = "7", SomeNumber = 7 },
}));
nameIndex = testTable.IndexDefine("name", to => to.Name);
connection.Run(nameIndex.IndexCreate());
connection.Run(nameIndex.IndexWait()).ToArray(); // ToArray ensures that the IEnumerable is actually evaluated completely and the wait is completed
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
connection.Run(Query.DbCreate("test"));
connection.Run(Query.Db("test").TableCreate("table"));
testTable = Query.Db("test").Table<TestObjectWithDictionary>("table");
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
connection.Run(Query.DbCreate("test"));
connection.Run(Query.Db("test").TableCreate("table"));
testTable = Query.Db("test").Table<TestObject>("table");
connection.Run(testTable.Insert(new TestObject[]
{
new TestObject() { Name = "1", SomeNumber = 1 },
new TestObject() { Name = "1", SomeNumber = 1 },
new TestObject() { Name = "2", SomeNumber = 2, Tags = new string[] { "A", "B" } },
new TestObject() { Name = "2", SomeNumber = 200 },
new TestObject() { Name = "2", SomeNumber = 2, Tags = new string[] { "A", "C" } },
new TestObject() { Name = "3", SomeNumber = 3 },
new TestObject() { Name = "3", SomeNumber = 3 },
new TestObject() { Name = "4", SomeNumber = 4 },
new TestObject() { Name = "5", SomeNumber = 5 },
new TestObject() { Name = "6", SomeNumber = 6 },
new TestObject() { Name = "6", SomeNumber = 6 },
new TestObject() { Name = "7", SomeNumber = 7 },
}));
nameIndex = testTable.IndexDefine("name", to => to.Name);
connection.Run(nameIndex.IndexCreate());
connection.Run(nameIndex.IndexWait());
}
/// <summary>
/// Create a new view of data
/// </summary>
/// <param name="query">Row Query</param>
/// <param name="name">Friendly name</param>
/// <param name="throttleTime">Minimum delay in milliseconds</param>
/// <returns>New table view</returns>
public ITableView CreateView(ITableQuery query, string name, int throttleTime)
{
return CreateView(query, name, null, throttleTime);
}
/// <summary>
/// Create a view with a predetermined set of of columns
/// </summary>
/// <param name="query">Row Query</param>
/// <param name="name">Friendly name</param>
/// <param name="columns">Set of columns</param>
/// <param name="throttleTime">Minimum delay in milliseconds</param>
/// <returns>New table view</returns>
public ITableView CreateView(ITableQuery query, string name, IList<IColumn> columns, int throttleTime)
{
ITableView view;
if (views.TryGetValue(name, out view)) return view;
view = new TableView(query, name, columns, throttleTime, RowRepository);
views.Add(name, view);
return view;
}
