public void ThenIValidateThatTheResponseBodyContainsTheFollowingValues(Table table) { var dictionary = TableUtils.ConvertToDictionary(table); var fieldsMapped = Mapper.MapValues(dictionary, helper.GetData()); AssertUtils.AssertExpectedValues(response, fieldsMapped); }
private List <string> ApplyWhereConditions(List <string> unfilteredRecords, string tableName) { var records = new List <string>(); var groupedConditions = new List <KeyValuePair <string, List <string> > >(); foreach (var condition in WhereConditionsList) { if (groupedConditions.Find(elem => elem.Key == condition.Item1.Item2).Value == null) { groupedConditions.Add(new KeyValuePair <string, List <string> >(condition.Item1.Item2, new List <string>())); } groupedConditions.Find(elem => elem.Key == condition.Item1.Item2).Value.Add(condition.Item2); } var tableStructure = TableUtils.GetTableColumns(DatabaseName, tableName); foreach (var record in unfilteredRecords) { if (RecordMatchesCondition(record, tableStructure, groupedConditions)) { records.Add(record); } } return(records); }
public void TestMethod1() { string[] header = { "et", "to", "tre" }; var wtu = new TableUtils(header); Assert.IsTrue(wtu.Columns[0].Name == "et"); }
private List <string> ApplyProjection(List <string> records) { var outputColumns = new List <string>(); var tableStructure = TableUtils.GetTableColumns(DatabaseName, TableName); if (AggregateFunctionList.Count == 0) { // Select the values of the columns from the record and add them to the output foreach (var record in records) { var outputRecord = ""; var recordSplit = record.Split('#'); foreach (var output in OutputParamsAliasList) { outputRecord += recordSplit[tableStructure.IndexOf(output.Item1.Item2)] + "#"; } // Apply DISTINCT as well outputRecord = outputRecord.Remove(outputRecord.Length - 1); if (!outputColumns.Contains(outputRecord)) { outputColumns.Add(outputRecord); } } } else { // Collect the result of the aggregations => This will always be one row } return(outputColumns); }
public async Task <Either <DomainError, Unit> > Delete(InterestedStorage subscription) { TableOperation deleteOperation = TableOperation.Delete(subscription.AddEtag()); var result = await TableUtils.TryExecute(() => _tableClient.ExecuteAsync(deleteOperation)); return(result.Map(x => unit)); }
private void CheckUniqueIndexConstraint(string record) { var columnValues = record.Split('#'); var mongoDB = new MongoDBAcess(DatabaseName); var indexFiles = TableUtils.GetIndexFiles(DatabaseName, TableName); foreach (var file in indexFiles) { if (file.IsUnique) { var createKeyOfUqIndex = ""; var pk = ""; for (int idx = 0; idx < ColumnsInfo.Count; idx++) { if (file.IndexColumns.Exists(elem => elem == ColumnsInfo[idx].ColumnName)) { createKeyOfUqIndex += columnValues[idx] + '#'; } if (ColumnsInfo[idx].PK) { pk = columnValues[idx] + "#"; } } createKeyOfUqIndex = createKeyOfUqIndex.Remove(createKeyOfUqIndex.Length - 1); pk = pk.Remove(pk.Length - 1); MongoDB.InsertKVIntoCollection(file.IndexFileName, createKeyOfUqIndex, pk); } } }
public ActionResult Shooter() { string connstring = RouteConfig.connectString; NpgsqlConnection connection = new NpgsqlConnection(connstring); connection.Open(); NpgsqlCommand command = new NpgsqlCommand("SELECT * FROM shooters.shooter", connection); NpgsqlDataReader dataReader = command.ExecuteReader(); NpgsqlDataAdapter da = new NpgsqlDataAdapter(); DataTable dt = new DataTable(); //for (int i = 0; dataReader.Read(); i++){} while (dataReader.Read()) { } dt.Load(dataReader); da.SelectCommand = command; da.Fill(dt); List <actor> _list = TableUtils.CreateListFromTable <actor>(dt); connection.Close(); var model = new Shooters() { }; model.Actors = _list; return(View(model)); // return View(); }
public ActionResult EditIncident(int iKey) { string query = "SELECT * FROM shooters.incitingIncident where iKey= '" + iKey + "'"; var _model = TableUtils.queryToObject <incitingIncident>(query); return(View(_model)); }
public Task <Either <DomainError, IImmutableList <string> > > GetTitles() { var tableQuery = new TableQuery <TitlesStorage>(); return(TableUtils.TryExecuteSimpleQuery(() => _tableClient.ExecuteQuerySegmentedAsync(tableQuery, null)) .BindAsync(Mapper)); }
public void TestMethod1() { string[] header = { "et", "to", "tre" }; var wtu = new TableUtils(header); StfAssert.StringEquals("Et", wtu.Columns[0].Name, "et"); }
private string CheckForPrimaryKey(List <Tuple <Tuple <string, string>, string> > conditionList) { if (conditionList.Count == 0) { return(""); } var columnsUsed = ""; var primaryKeyColumns = TableUtils.GetPrimaryKey(DatabaseName, TableName); var primaryKeyColumnsString = ""; foreach (var primaryKey in primaryKeyColumns) { primaryKeyColumnsString += primaryKey + "_"; } primaryKeyColumnsString = primaryKeyColumnsString.Remove(primaryKeyColumnsString.Length - 1); foreach (var column in conditionList) { columnsUsed += column.Item1.Item2 + "_"; } if (columnsUsed != "") { columnsUsed = columnsUsed.Remove(columnsUsed.Length - 1); if (primaryKeyColumnsString.Contains(columnsUsed)) { // the primary key of the table can be used if the attributes are a prefix of the attributes in the primary key structure return(columnsUsed); } } return(""); }
public override IQueryable <PostDTO> Query() { var query = Context.Set <Post>().Where(item => item.UserId == _userId).ProjectTo <PostDTO>(_config); query = TableUtils.ApplyDeletedFilter(query, IncludeDeleted); return(query); }
public async Task <Either <DomainError, IImmutableList <InterestedStorage> > > Get(Email userEmail) { var user = OptionUtils.UnpackOption(userEmail.Value, string.Empty); var tableQuery = new TableQuery <InterestedStorage>().Where(TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, user)); return(await TableUtils.TryGetAllTableElements(_tableClient, tableQuery)); }
private bool TryOpen(TableLineRef inRef) { UnityEngine.Object obj = inRef.TableSource as UnityEngine.Object; if (obj == null) { return(false); } if (!TryEdit(obj)) { return(false); } int ruleIdx = TableUtils.IndexOfRule(m_SelectionState.Table, inRef.RuleId); if (ruleIdx >= 0) { SelectRule(ruleIdx); if (inRef.ConditionIndex >= 0) { SelectCondition(inRef.ConditionIndex); } else if (inRef.ActionIndex >= 0) { SelectAction(inRef.ActionIndex); } } m_SelectionState.Refresh(); return(true); }
public async Task DeleteAllTest() { IEnumerable <TestTableEntity> rows = null; IEnumerable <TestTableEntity> rowsAfterDelete = null; using (var connection = new SqlConnection(Settings.ConnectionString)) { await TableUtils.ClearTestDB(connection); IEnumerable <object> list = new List <object>() { new { TestString = "HI", TestInt = 5 }, new { TestString = "HI2", TestInt = 6 }, new { TestString = "HI3", TestInt = 7 } }; await connection.InsertMulti("TestTable", list); rows = await connection.QueryAsync <TestTableEntity>("Select * from TestTable ORDER BY TestTableID;"); await connection.DeleteAll("TestTable"); rowsAfterDelete = await connection.QueryAsync <TestTableEntity>("Select * from TestTable ORDER BY TestTableID;"); } Assert.AreEqual(3, rows.Count()); Assert.AreEqual(0, rowsAfterDelete.Count()); }
public ActionResult EditGunPurchase(int gpId = 9) { string query = "select * from shooters.gunPurchase where gpid = " + gpId; gunPurchase gp = TableUtils.queryToObject <gunPurchase>(query); return(View(gp)); }
public ActionResult ViewHealthDetails(string mName) { string query = "select * from shooters.massshootings where mName = '" + mName + "'"; massShooting ms = TableUtils.queryToObject <massShooting>(query); return(View(ms)); }
public override IQueryable <TData> Query() { IQueryable <TData> query = this.Context.Set <TModel>().Project().To <TData>(); query = TableUtils.ApplyDeletedFilter(query, this.IncludeDeleted); return(query); }
public override IQueryable <TData> Query() { var query = Context.Set <TModel>().ProjectTo <TData>(_config); query = TableUtils.ApplyDeletedFilter(query, IncludeDeleted); return(query); }
public void Table_utils_write_should_write_a_table2() { // Arrange var(console, stdOut, _) = VirtualConsole.CreateBuffered(isOutputRedirected: false, isErrorRedirected: false); // Act TableUtils.Write(console, _testData.GroupBy(x => x.Group), new string[] { "Header0", "Header1", "Header2" }, null, x => x.Integer.ToString(), x => x.Str ?? string.Empty); // Assert string output = stdOut.GetString(); output.Should().NotBeNullOrWhiteSpace(); output.Should().ContainAll("Header0", "Header1", "testA", "testB", "testC", "testD", "0", "1", "2", "3", "4", "X", "Z", "X (2)", "Z (2)", "(1)"); output.Should().NotContainAll("Header2"); _output.WriteLine(output); }
public async Task <Either <DomainError, InterestedStorage> > Merge(InterestedStorage subscription) { TableOperation insertOrMergeOperation = TableOperation.InsertOrMerge(subscription); var result = await TableUtils.TryExecute(() => _tableClient.ExecuteAsync(insertOrMergeOperation)); return(result.Map(r => (InterestedStorage)r.Result)); }
public void TestTableCreate() { CrateDataReader reader = null; List <Table> schemadata = null; var tabledesc = (CrateTable)Attribute.GetCustomAttribute(typeof(CreatTestTable), typeof(CrateTable)); Assert.IsNotNull(tabledesc); TableUtils.DropTable(tabledesc.Name); using (var conn = TestCrateConnection()) { conn.Open(); conn.CreateTable <CreatTestTable>(); var sql = "SELECT * FROM information_schema.tables WHERE table_name= '" + tabledesc.Name + "'"; using (var cmd = new CrateCommand(sql, conn)) { reader = (CrateDataReader)cmd.ExecuteReader(); schemadata = reader.ToList <Table>(); } } Assert.IsNotNull(reader); Assert.IsNotNull(schemadata); Assert.Greater(schemadata.Count, 0); Assert.AreEqual(EnumHelpers.Replication(tabledesc.NumberOfReplicas), schemadata[0].NumberOfReplicas); Assert.AreEqual(tabledesc.NumberOfShards, schemadata[0].NumberOfShards); }
public async Task DeleteByIDTest() { IEnumerable <TestTableEntity> rows = null; IEnumerable <TestTableEntity> rowsAfterDelete = null; using (var connection = new SqlConnection(Settings.ConnectionString)) { await TableUtils.ClearTestDB(connection); IEnumerable <object> list = new List <object>() { new { TestString = "HI", TestInt = 5 }, new { TestString = "HI2", TestInt = 6 }, new { TestString = "HI3", TestInt = 7 } }; await connection.InsertMulti("TestTable", list); rows = await connection.QueryAsync <TestTableEntity>("Select * from TestTable ORDER BY TestTableID;"); await connection.Delete("TestTable", new { TestTableID = rows.First().TestTableID }); rowsAfterDelete = await connection.QueryAsync <TestTableEntity>("Select * from TestTable ORDER BY TestTableID;"); } Assert.AreEqual(3, rows.Count()); Assert.AreEqual(2, rowsAfterDelete.Count()); // Compare IDs to ensure proper entity was deleted. Assert.AreEqual(rows.Skip(1).First().TestTableID, rowsAfterDelete.First().TestTableID); Assert.AreEqual(rows.Skip(2).First().TestTableID, rowsAfterDelete.Skip(1).First().TestTableID); }
public Task <Either <DomainError, IEnumerable <AnimeInfoWithImageStorage> > > GetBySeason(Season season, int year) { var partitionKey = IdHelpers.GenerateAnimePartitionKey(season, (ushort)year); var tableQuery = new TableQuery <AnimeInfoWithImageStorage>(). Where(TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, partitionKey)); return(TableUtils.TryExecuteSimpleQuery(() => _tableClient.ExecuteQuerySegmentedAsync(tableQuery, null))); }
public ActionResult Guns(string first, string last) { List <gun> _list = TableUtils.queryToTable <gun>("SELECT * FROM shooters.Gun"); Guns model = new Guns(); model._guns = _list; return(View(model)); // return View(); }
private void OnGUI() { RegenContext(); SyncAllowedListOperations(); float width = this.position.width; float thirdWidth = Mathf.Max(width / 3, 300) - EditorStyles.helpBox.padding.left; using (new EditorGUILayout.HorizontalScope()) { using (new EditorGUILayout.VerticalScope(GUILayout.Width(thirdWidth), GUILayout.ExpandWidth(true))) { GUILayout.Space(4); using (new EditorGUILayout.VerticalScope(EditorStyles.helpBox, GUILayout.Width(thirdWidth), GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(true))) { RuleTableGUI(); GUILayout.FlexibleSpace(); } using (new EditorGUILayout.VerticalScope(EditorStyles.helpBox, GUILayout.Width(thirdWidth), GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(true))) { ErrorGUI(); } using (new EditorGUILayout.VerticalScope(EditorStyles.helpBox, GUILayout.Width(thirdWidth), GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(true))) { ConfigGUI(); } GUILayout.Space(4); } EditorGUI.BeginChangeCheck(); { using (new EditorGUILayout.VerticalScope(EditorStyles.helpBox, GUILayout.Width(thirdWidth), GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(true))) { RuleInfoGUI(); } using (new EditorGUILayout.VerticalScope(EditorStyles.helpBox, GUILayout.Width(thirdWidth), GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(true))) { ConditionInfoGUI(); ActionInfoGUI(); } } if (EditorGUI.EndChangeCheck() && m_SelectionState.Rule != null && m_Context.Library != null) { RuleFlags flags = TableUtils.GetRuleFlags(m_SelectionState.Rule, m_Context.Library); if (flags != m_SelectionState.Rule.Flags) { m_TargetState.UndoTarget.MarkDirty("Modified rule flags"); m_SelectionState.Rule.Flags = flags; } } } }
public ActionResult Shooter(string first, string last) { string query = "SELECT * FROM shooters.shooter"; List <actor> _actors = TableUtils.queryToTable <actor>(query); Shooters _shooters = new Shooters(); _shooters.Actors = _actors; return(View(_shooters)); }
private void RemoveFromFKIndexFiles(MongoDBAcess mongoDB) { ForeignKeyFiles.Clear(); ForeignKeyFiles = TableUtils.GetOwnForeignKeyFiles(DatabaseName, TableName); foreach (var foreignKey in ForeignKeyFiles) { mongoDB.RemoveValueFromCollection(foreignKey, RemovedKey); } }
public ViewResult GunsNoType(int?page) { int pageSize = 10; int pageNumber = (page ?? 1); string query = "select * from shooters.gun where gname NOT in (select gName from shooters.gun natural join shooters.gunTypeRel)"; var _guns = TableUtils.queryToTable <gun>(query); return(View(_guns.ToPagedList(pageNumber, pageSize))); }
public ViewResult ShooterNoIncidents(int?page) { int pageSize = 10; int pageNumber = (page ?? 1); string query = "select * from shooters.shooter where first NOT IN (select first from shooters.incitingincident) AND last NOT IN (select last from shooters.incitingincident)";; var _shooters = TableUtils.queryToTable <actor>(query); return(View(_shooters.ToPagedList(pageNumber, pageSize))); }