public void CaseExpression_Dont_Overrun() { List <TSQLStatement> statements = TSQLStatementReader.ParseStatements( @" BEGIN SELECT CASE WHEN 1 = 2 THEN 0 ELSE 1 END END" // normalizing line endings to unix format to ensure passing // tests in various environments .Replace("\r", ""), includeWhitespace: false); Assert.AreEqual(3, statements.Count); Assert.AreEqual(1, statements[0].Tokens.Count); TokenComparisons.CompareTokenLists( new List <TSQLToken>() { new TSQLKeyword(18, "SELECT"), new TSQLKeyword(25, "CASE"), new TSQLKeyword(30, "WHEN"), new TSQLNumericLiteral(35, "1"), new TSQLOperator(37, "="), new TSQLNumericLiteral(39, "2"), new TSQLKeyword(41, "THEN"), new TSQLNumericLiteral(46, "0"), new TSQLKeyword(48, "ELSE"), new TSQLNumericLiteral(53, "1"), new TSQLKeyword(55, "END") }, statements[1].Tokens); Assert.AreEqual(1, statements[2].Tokens.Count); Assert.IsTrue(statements[2].Tokens[0].IsKeyword(TSQLKeywords.END)); }
public void WithStatement_Select() { List <TSQLStatement> statements = TSQLStatementReader.ParseStatements( @"WITH [EMP_cte]([BusinessEntityID], [OrganizationNode], [FirstName], [LastName], [RecursionLevel]) -- CTE name and columns AS ( SELECT e.[BusinessEntityID], e.[OrganizationNode], p.[FirstName], p.[LastName], 0 -- Get the initial list of Employees for Manager n FROM [HumanResources].[Employee] e INNER JOIN [Person].[Person] p ON p.[BusinessEntityID] = e.[BusinessEntityID] WHERE e.[BusinessEntityID] = @BusinessEntityID UNION ALL SELECT e.[BusinessEntityID], e.[OrganizationNode], p.[FirstName], p.[LastName], [RecursionLevel] + 1 -- Join recursive member to anchor FROM [HumanResources].[Employee] e INNER JOIN [EMP_cte] ON e.[OrganizationNode].GetAncestor(1) = [EMP_cte].[OrganizationNode] INNER JOIN [Person].[Person] p ON p.[BusinessEntityID] = e.[BusinessEntityID] ) -- Join back to Employee to return the manager name SELECT [EMP_cte].[RecursionLevel], [EMP_cte].[OrganizationNode].ToString() as [OrganizationNode], p.[FirstName] AS 'ManagerFirstName', p.[LastName] AS 'ManagerLastName', [EMP_cte].[BusinessEntityID], [EMP_cte].[FirstName], [EMP_cte].[LastName] -- Outer select from the CTE FROM [EMP_cte] INNER JOIN [HumanResources].[Employee] e ON [EMP_cte].[OrganizationNode].GetAncestor(1) = e.[OrganizationNode] INNER JOIN [Person].[Person] p ON p.[BusinessEntityID] = e.[BusinessEntityID] ORDER BY [RecursionLevel], [EMP_cte].[OrganizationNode].ToString() OPTION (MAXRECURSION 25)" , includeWhitespace: false); Assert.AreEqual(1, statements.Count); Assert.IsInstanceOf(typeof(TSQLSelectStatement), statements[0]); }
public void CaseExpression_Regression_Duplicated_Case() { List <TSQLStatement> statements = TSQLStatementReader.ParseStatements( @"select case when abi = '03654' then 0 else 1 end as abi;", includeWhitespace: false); Assert.AreEqual(1, statements.Count); List <TSQLToken> tokens = statements[0].Tokens; TokenComparisons.CompareTokenLists( new List <TSQLToken>() { new TSQLKeyword(0, "select"), new TSQLKeyword(7, "case"), new TSQLKeyword(12, "when"), new TSQLIdentifier(17, "abi"), new TSQLOperator(21, "="), new TSQLStringLiteral(23, "'03654'"), new TSQLKeyword(31, "then"), new TSQLNumericLiteral(36, "0"), new TSQLKeyword(38, "else"), new TSQLNumericLiteral(43, "1"), new TSQLKeyword(45, "end"), new TSQLKeyword(49, "as"), new TSQLIdentifier(52, "abi") }, tokens); }
public void UpdateStatement_FullFunctionality() { List <TSQLStatement> statements = TSQLStatementReader.ParseStatements( @" UPDATE t SET t.Column1 = 'something', t.Column2 = 2 OUTPUT deleted.* INTO #holder (ID, Column1, Column2) FROM dbo.SomeTable t WHERE t.ID = 1 OPTION (RECOMPILE);" , includeWhitespace: false); TSQLUpdateStatement update = statements[0].AsUpdate; Assert.AreEqual(42, update.Tokens.Count); Assert.AreEqual(12, update.Set.Tokens.Count); Assert.AreEqual(13, update.Output.Tokens.Count); Assert.AreEqual(9, update.Output.Into.Tokens.Count); Assert.AreEqual(5, update.From.Tokens.Count); Assert.AreEqual(6, update.Where.Tokens.Count); Assert.AreEqual(4, update.Option.Tokens.Count); }
public void InsertStatement_Select() { string sql = @" INSERT INTO dbo.EmployeeSales SELECT 'SELECT', sp.BusinessEntityID, c.LastName, sp.SalesYTD FROM Sales.SalesPerson AS sp INNER JOIN Person.Person AS c ON sp.BusinessEntityID = c.BusinessEntityID WHERE sp.BusinessEntityID LIKE '2%' ORDER BY sp.BusinessEntityID, c.LastName;" ; List <TSQLStatement> statements = TSQLStatementReader.ParseStatements( sql, includeWhitespace: false); TSQLInsertStatement insert = statements[0].AsInsert; Assert.AreEqual(55, insert.Tokens.Count); Assert.IsNull(insert.With); Assert.IsNull(insert.Output); Assert.IsNull(insert.Values); Assert.IsNull(insert.Default); Assert.IsNull(insert.Execute); Assert.AreEqual(5, insert.Insert.Tokens.Count); Assert.AreEqual(50, insert.Select.Tokens.Count); }
private void ExecuteSql(int update, ref bool started) { var queryText = AddSqlForVariables(SqlQuery); var statements = TSQLStatementReader.ParseStatements(queryText); if (queryText.Contains("UNION") && statements.Count == 2) { var tables = statements[0].GetAllTables(); foreach (var table in tables) { LoadRecordset(table.TableName); } var sqlQueryToUpdate = queryText; foreach (var item in AdvancedRecordset.HashedRecSets) { sqlQueryToUpdate = sqlQueryToUpdate.Replace(item.recSet, item.hashCode); } var results = AdvancedRecordset.ExecuteQuery(sqlQueryToUpdate); foreach (DataTable dt in results.Tables) { AdvancedRecordset.ApplyResultToEnvironment(dt.TableName, Outputs, dt.Rows.Cast <DataRow>().ToList(), false, update, ref started); } } else { ExecuteAllSqlStatements(update, statements, ref started); } }
public void SelectStatement_WindowedAggregate() { List <TSQLStatement> statements = TSQLStatementReader.ParseStatements(@" SELECT *, ROW_NUMBER() OVER ( PARTITION BY some_field ORDER BY some_other_field) AS some_row_number FROM my_db.my_schema.my_table" , includeWhitespace: false); Assert.AreEqual(1, statements.Count); Assert.AreEqual(TSQLStatementType.Select, statements[0].Type); TSQLSelectStatement select = statements[0] as TSQLSelectStatement; Assert.AreEqual(23, select.Tokens.Count); Assert.AreEqual(17, select.Select.Tokens.Count); Assert.AreEqual(6, select.From.Tokens.Count); Assert.AreEqual(2, select.Select.Columns.Count); }
public void AdvancedRecordset_Converter_ExpectCanRunMultipleQueries() { string query = "select CURRENT_TIMESTAMP;" + "select * from address;update person set Age=20 where Name=\"zak\";" + "select * from person p join address a on p.address_id=a.id where a.addr=\"11 test lane\" order by Name"; var worker = CreatePersonAddressWorkers(); var statements = TSQLStatementReader.ParseStatements(query); var updatedQuery = ""; foreach (var statement in statements) { updatedQuery += worker.UpdateSqlWithHashCodes(statement) + ";"; } var results = worker.ExecuteQuery(updatedQuery); Assert.AreEqual("bob", Encoding.UTF8.GetString(results.Tables[2].Rows[0]["Name"] as byte[])); Assert.AreEqual(21, int.Parse(Encoding.UTF8.GetString(results.Tables[2].Rows[0]["Age"] as byte[]))); Assert.AreEqual(1, int.Parse(Encoding.UTF8.GetString(results.Tables[2].Rows[0]["address_id"] as byte[]))); Assert.AreEqual("11 test lane", Encoding.UTF8.GetString(results.Tables[1].Rows[0]["Addr"] as byte[])); Assert.AreEqual(3421, int.Parse(Encoding.UTF8.GetString(results.Tables[1].Rows[0]["Postcode"] as byte[]))); Assert.AreEqual("jef", Encoding.UTF8.GetString(results.Tables[2].Rows[1]["Name"] as byte[])); Assert.AreEqual(24, int.Parse(Encoding.UTF8.GetString(results.Tables[2].Rows[1]["Age"] as byte[]))); }
public void AdvancedRecordset_Converter_ConvertDataTableToRecordset_ExpectDataInIEnvironment() { string returnRecordsetName = "person"; string query = "select * from person"; var worker = CreatePersonAddressWorkers(); var statements = TSQLStatementReader.ParseStatements(query); var updatedQuery = worker.UpdateSqlWithHashCodes(statements[0]); var results = worker.ExecuteQuery(updatedQuery); var started = false; // apply sql results to environment worker.ApplyResultToEnvironment(returnRecordsetName, new List <IServiceOutputMapping>(), results.Tables[0].Rows.Cast <DataRow>().ToList(), false, 0, ref started); // fetch newly inserted data from environment var internalResult = worker.Environment.EvalAsList("[[person(*).name]]", 0); // assert that data fetched is what we expect from sql var e = internalResult.GetEnumerator(); if (e.MoveNext()) { Assert.AreEqual(e.Current, "bob"); } else { Assert.Fail(); } }
public IEnumerable <SqlMatch> Parse(string sqlText) { foreach (var tokens in TSQLStatementReader.ParseStatements(CleanUp(sqlText)).Select(s => s.Tokens)) { var previous = tokens.First(); var queryType = GetQueryType(previous); if (queryType == QueryType.Unknown) { continue; } var targets = new HashSet <string>(); var collect = previous.Text == "UPDATE"; string tmp = null; foreach (var token in tokens.Skip(1)) { switch (token) { case TSQLKeyword keyword: collect = _keywords.Contains(keyword.Text, StringComparer.InvariantCultureIgnoreCase); if (!string.IsNullOrEmpty(tmp)) { targets.Add(tmp); tmp = null; } break; case TSQLIdentifier identifier: if (!collect || _ignore.Contains(identifier.Text, StringComparer.InvariantCultureIgnoreCase)) { continue; } if (previous.Text == ".") { tmp += $".{identifier.Name}"; } else { if (tmp != null) { targets.Add(tmp); } tmp = previous is TSQLIdentifier ? null : identifier.Name; } break; } previous = token; } if (!string.IsNullOrEmpty(tmp)) { targets.Add(tmp); } yield return(new SqlMatch { Targets = targets.ToArray(), Type = queryType }); } }
public static void ParseTSqlFragment() { List <TSQLStatement> statements = TSQLStatementReader.ParseStatements( @"select AreaId = A.mcw_areaId, SurrogateKey = A.AreaKey, Code = S.statecode, Name = S.statename From CRM.dim_Area as A inner join CRM.dim_AreaState as S ON A.statecode = S.statecode ; DELETE FROM blogs where url='dasfds'", includeWhitespace: true); Console.WriteLine(statements.Count); for (int i = 0; i < statements.Count; i++) { Console.WriteLine("-------Statement-----{0}", i); Console.WriteLine(statements[0]); TSQLSelectStatement select = statements[i] as TSQLSelectStatement; Console.WriteLine(TSQLStatementType.Select + "----->" + statements[i].Type); if (statements[i].Type != TSQLStatementType.Unknown) { Console.WriteLine("----->" + select.Tokens.Count); Console.WriteLine(TSQLKeywords.SELECT + "----->" + select.Tokens[0].AsKeyword.Keyword); Console.WriteLine(" ", select.Tokens[1].AsWhitespace.Text); Console.WriteLine("t", select.Tokens[2].AsIdentifier.Name); Console.WriteLine(TSQLCharacters.Period + "----->" + select.Tokens[3].AsCharacter.Character); Console.WriteLine("----->" + select.Select.Tokens.Count); Console.WriteLine("----->" + select.Into.Tokens.Count); Console.WriteLine("----->" + select.From.Tokens.Count); Console.WriteLine("----->" + select.Where.Tokens.Count); Console.WriteLine("----->" + select.GroupBy.Tokens.Count); Console.WriteLine("----->" + select.Having.Tokens.Count); Console.WriteLine("----->" + select.OrderBy.Tokens.Count); } } }
public void SqliteServer_ParseTSQL_SelectStatement_SelectLiteral() { //------------Setup for test-------------------------- try { //------------Execute Test--------------------------- List <TSQLStatement> statements = TSQLStatementReader.ParseStatements( "select 1;", includeWhitespace: true); TSQLSelectStatement select = statements[0] as TSQLSelectStatement; Assert.IsNotNull(statements); Assert.AreEqual(1, statements.Count); Assert.AreEqual(TSQLStatementType.Select, statements[0].Type); Assert.AreEqual(3, select.Tokens.Count); Assert.AreEqual(TSQLKeywords.SELECT, select.Tokens[0].AsKeyword.Keyword); Assert.AreEqual(" ", select.Tokens[1].AsWhitespace.Text); Assert.AreEqual("1", select.Tokens[2].AsNumericLiteral.Text); //------------Assert Results------------------------- } finally { } }
private bool MssqlIsStoredProcForXmlResult(SqlConnection connection, string procedureName) { bool result = false; var procSqlScript = MssqlGetSqlForProcedure(connection, procedureName); var statements = TSQLStatementReader.ParseStatements(procSqlScript); foreach (var statement in statements) { var tokens = statement.Tokens; var cnt = tokens.Count; if (cnt < 3) { continue; } var i = 0; for (; i < tokens.Count; i++) { if (tokens[i].Type == TSQL.Tokens.TSQLTokenType.Keyword && tokens[i].Text.ToUpper() == "FOR") { i++; result = (i < tokens.Count && tokens[i].Type == TSQL.Tokens.TSQLTokenType.Identifier && tokens[i].Text == "XML"); } } } return(result); }
public void SelectStatement_TwoLiteralSelects() { List <TSQLStatement> statements = TSQLStatementReader.ParseStatements( "select 1;select 2;", includeWhitespace: true); TSQLSelectStatement select1 = statements[0] as TSQLSelectStatement; TSQLSelectStatement select2 = statements[1] as TSQLSelectStatement; Assert.IsNotNull(statements); Assert.AreEqual(2, statements.Count); Assert.AreEqual(TSQLStatementType.Select, select1.Type); Assert.AreEqual(3, select1.Tokens.Count); Assert.AreEqual(TSQLKeywords.SELECT, select1.Tokens[0].AsKeyword.Keyword); Assert.AreEqual(" ", select1.Tokens[1].AsWhitespace.Text); Assert.AreEqual("1", select1.Tokens[2].AsNumericLiteral.Text); Assert.AreEqual(1, select1.Select.Columns.Count); Assert.AreEqual(TSQLStatementType.Select, select2.Type); Assert.AreEqual(3, select2.Tokens.Count); Assert.AreEqual(TSQLKeywords.SELECT, select2.Tokens[0].AsKeyword.Keyword); Assert.AreEqual(" ", select2.Tokens[1].AsWhitespace.Text); Assert.AreEqual("2", select2.Tokens[2].AsNumericLiteral.Text); Assert.AreEqual(1, select2.Select.Columns.Count); }
public void SelectStatement_CommonSelect() { List <TSQLStatement> statements = TSQLStatementReader.ParseStatements( @"select t.a, t.b, (select 1) as e into #tempt from [table] t inner join [table] t2 on t.id = t2.id where t.c = 5 group by t.a, t.b having count(*) > 1 order by t.a, t.b;" , includeWhitespace: true); TSQLSelectStatement select = statements[0] as TSQLSelectStatement; Assert.IsNotNull(statements); Assert.AreEqual(1, statements.Count); Assert.AreEqual(TSQLStatementType.Select, statements[0].Type); Assert.AreEqual(98, select.Tokens.Count); Assert.AreEqual(TSQLKeywords.SELECT, select.Tokens[0].AsKeyword.Keyword); TSQLSelectClause selectClause = select.Select; Assert.AreEqual(3, selectClause.Columns.Count); TSQLSelectColumn column = selectClause.Columns[0]; Assert.AreEqual(TSQLExpressionType.Column, column.Expression.Type); Assert.AreEqual("t", column.Expression.AsColumn.TableReference.Single().AsIdentifier.Name); Assert.AreEqual("a", column.Expression.AsColumn.Column.Name); column = selectClause.Columns[1]; Assert.AreEqual(TSQLExpressionType.Column, column.Expression.Type); Assert.AreEqual("t", column.Expression.AsColumn.TableReference.Single().AsIdentifier.Name); Assert.AreEqual("b", column.Expression.AsColumn.Column.Name); column = selectClause.Columns[2]; Assert.AreEqual("e", column.ColumnAlias.AsIdentifier.Name); Assert.AreEqual(TSQLExpressionType.Subquery, column.Expression.Type); TSQLSubqueryExpression subquery = column.Expression.AsSubquery; Assert.AreEqual(1, subquery.Select.Select.Columns.Count); Assert.AreEqual(1, subquery.Select.Select.Columns[0].Expression.AsConstant.Literal.AsNumericLiteral.Value); Assert.AreEqual(" ", select.Tokens[1].AsWhitespace.Text); Assert.AreEqual("t", select.Tokens[2].AsIdentifier.Name); Assert.AreEqual(TSQLCharacters.Period, select.Tokens[3].AsCharacter.Character); Assert.AreEqual(22, select.Select.Tokens.Count); Assert.AreEqual(4, select.Into.Tokens.Count); Assert.AreEqual(26, select.From.Tokens.Count); Assert.AreEqual(10, select.Where.Tokens.Count); Assert.AreEqual(13, select.GroupBy.Tokens.Count); Assert.AreEqual(11, select.Having.Tokens.Count); Assert.AreEqual(12, select.OrderBy.Tokens.Count); Assert.AreEqual(3, select.Select.Columns.Count); Assert.AreEqual("e", select.Select.Columns[2].ColumnAlias.Text); }
public void SelectStatement_MultiLevelParens() { string query = "SELECT ((A/B)-1) FROM SomeTable"; var statements = TSQLStatementReader.ParseStatements(query); Assert.AreEqual(1, statements.Count); Assert.AreEqual(12, statements[0].Tokens.Count); }
public void TSqlStatementExtensions_GetAllTables_SkipToken() { var statements = TSQLStatementReader.ParseStatements("Select person.name as firstname from Person p"); var tables = statements[0].GetAllTables(); Assert.AreEqual(1, tables.Count); Assert.AreEqual("Person", tables[0].TableName); }
public void TSqlStatementExtensions_GetAllTables_Offset() { var statements = TSQLStatementReader.ParseStatements("SELECT Name, ProductNumber, StandardCost FROM Production.Product ORDER BY StandardCost OFFSET 10 ROWS FETCH NEXT 10 ROWS ONLY"); var tables = statements[0].GetAllTables(); Assert.AreEqual(2, tables.Count); Assert.AreEqual("Production", tables[0].TableName); Assert.AreEqual("Product", tables[1].TableName); }
public void AdvancedRecordset_ReturnSql() { List <TSQLStatement> statements = TSQLStatementReader.ParseStatements("select * from person;", includeWhitespace: true); TSQLSelectStatement select = statements[0] as TSQLSelectStatement; var Worker = CreatePersonAddressWorkers(); var sql = Worker.ReturnSql(select.Tokens); Assert.AreEqual("select * from person", sql); }
public void MergeStatement_StandardMerge_UsingSelectFromCTE() { List <TSQLStatement> statements = TSQLStatementReader.ParseStatements( @" WITH myCTE (cteColumn1, cteColumn2) AS ( SELECT column1, column2 FROM cteSourceTable WHERE column2 IS NOT NULL ) MERGE INTO [t].[a] AS [Target] USING ( SELECT cteColumn1, cteColumn2 FROM myCTE ) AS [Source] ON ([Target].[ID] = [Source].[cteColumn1]) WHEN MATCHED AND ( NULLIF([Source].[cteColumn2], [Target].[Val]) IS NOT NULL OR NULLIF([Target].[Val], [Source].[cteColumn2]) IS NOT NULL) THEN UPDATE SET [Target].[Val] = [Source].[cteColumn2] WHEN NOT MATCHED BY TARGET THEN INSERT([ID],[Val]) VALUES([Source].[cteColumn1],[Source].[cteColumn2]) WHEN NOT MATCHED BY SOURCE THEN DELETE OUTPUT $ACTION AS [Action] ,DELETED.[ID] ,DELETED.[Val] ,INSERTED.[ID] ,INSERTED.[Val];" , includeWhitespace: true); TSQLMergeStatement merge = statements[0] as TSQLMergeStatement; Assert.IsNotNull(statements); Assert.AreEqual(1, statements.Count); Assert.AreEqual(TSQLStatementType.Merge, statements[0].Type); Assert.AreEqual(219, merge.Tokens.Count); Assert.AreEqual(TSQLKeywords.WITH, merge.Tokens[0].AsKeyword.Keyword); Assert.AreEqual(TSQLKeywords.MERGE, merge.Tokens[38].AsKeyword.Keyword); Assert.AreEqual(" ", merge.Tokens[39].AsWhitespace.Text); Assert.AreEqual(TSQLKeywords.INTO, merge.Tokens[40].AsKeyword.Keyword); Assert.AreEqual(" ", merge.Tokens[41].AsWhitespace.Text); Assert.AreEqual("t", merge.Tokens[42].AsIdentifier.Name); Assert.AreEqual(38, merge.With.Tokens.Count); Assert.AreEqual(2, merge.Merge.Tokens.Count); Assert.AreEqual(10, merge.Into.Tokens.Count); Assert.AreEqual(21, merge.Using.Tokens.Count); Assert.AreEqual(14, merge.On.Tokens.Count); Assert.AreEqual(3, merge.When.Count); Assert.AreEqual(63, merge.When[0].Tokens.Count); Assert.AreEqual(30, merge.When[1].Tokens.Count); Assert.AreEqual(14, merge.When[2].Tokens.Count); Assert.AreEqual(27, merge.Output.Tokens.Count); }
public void ExecuteStatement_ShortWord() { List <TSQLStatement> statements = TSQLStatementReader.ParseStatements( @"EXEC sp_who2;", includeWhitespace: false); TSQLExecuteStatement exec = statements[0].AsExecute; Assert.AreEqual(1, statements.Count); Assert.AreEqual(2, exec.Tokens.Count); }
public void ExecuteStatement_NoEnd() { List <TSQLStatement> statements = TSQLStatementReader.ParseStatements( @"sp_who2 select 1", includeWhitespace: false); TSQLExecuteStatement exec = statements[0].AsExecute; Assert.AreEqual(2, statements.Count); Assert.AreEqual(1, exec.Tokens.Count); }
public void AdvancedRecordset_ExecuteScalar() { var worker = CreatePersonAddressWorkers(); var query = "select * from person where Name=\"zak\";"; var statements = TSQLStatementReader.ParseStatements(query); var updatedQuery = worker.UpdateSqlWithHashCodes(statements[0]); var result = worker.ExecuteScalar(updatedQuery); Assert.AreEqual(3, result); }
public void AdvancedRecordset_Converter_CanRunWhereQuery_ExpectNoResults() { string query = "select * from person p join address a on p.address_id=a.id where p.Name=\"zak\""; var worker = CreatePersonAddressWorkers(); var statements = TSQLStatementReader.ParseStatements(query); var updatedQuery = worker.UpdateSqlWithHashCodes(statements[0]); var results = worker.ExecuteQuery(updatedQuery); Assert.AreEqual(0, results.Tables[0].Rows.Count); }
public void AdvancedRecordset_Converter_CanRunQueryContainingAlias() { string query = "select name as username from person"; var worker = CreatePersonAddressWorkers(); var statements = TSQLStatementReader.ParseStatements(query); var updatedQuery = worker.UpdateSqlWithHashCodes(statements[0]); var results = worker.ExecuteQuery(updatedQuery); Assert.AreEqual(4, results.Tables[0].Rows.Count); }
static void Main(string[] args) { TSQLSelectStatement select = TSQLStatementReader.ParseStatements(@" SELECT OrderDateKey, SUM(SalesAmount) AS TotalSales FROM FactInternetSales GROUP BY OrderDateKey HAVING OrderDateKey > 20010000 ORDER BY OrderDateKey;" )[0] as TSQLSelectStatement; Console.ReadKey(); }
private List <string> ParseColumnNamesFromSql() { var statement = TSQLStatementReader.ParseStatements(SqlForRead).FirstOrDefault() as TSQLSelectStatement; List <string> columNames = statement?.Select .Tokens .Where(token => token.Type == TSQL.Tokens.TSQLTokenType.Identifier) .Select(token => token.AsIdentifier.Name) .ToList(); return(columNames); }
public void AdvancedRecordset_Converter_CanRunJoinQuery_ExpectAllResults() { var worker = CreatePersonAddressWorkers(); string query = "select * from person p join address a on p.address_id=a.id"; var statements = TSQLStatementReader.ParseStatements(query); var updatedQuery = worker.UpdateSqlWithHashCodes(statements[0]); var results = worker.ExecuteQuery(updatedQuery); Assert.IsInstanceOfType(results, typeof(DataSet)); Assert.AreEqual(3, results.Tables[0].Rows.Count); }
public void SelectStatement_CASTMissingASRegression() { // regression test for https://github.com/bruce-dunwiddie/tsql-parser/issues/89 List <TSQLStatement> statements = TSQLStatementReader.ParseStatements( @"SELECT CAST ( 123.45 AS INT ) ", includeWhitespace: true); Assert.AreEqual(1, statements.Count); TSQLSelectStatement select = statements.Single().AsSelect; Assert.AreEqual(14, select.Tokens.Count); }
public void SelectStatement_MultipleSetOperatorsRegressionWithWhitespace() { // regression test for https://github.com/bruce-dunwiddie/tsql-parser/issues/81 List <TSQLStatement> statements = TSQLStatementReader.ParseStatements( @"SELECT 1 UNION SELECT 2 UNION SELECT 3" , includeWhitespace: true); Assert.AreEqual(1, statements.Count); TSQLSelectStatement select = statements.Single().AsSelect; Assert.AreEqual(15, select.Tokens.Count); Assert.AreEqual(2, select.SetOperators.Count); Assert.AreEqual(1, select .Select .Columns .Single() .Expression .AsConstant .Literal .AsNumericLiteral .Value); Assert.AreEqual(2, select .SetOperators[0] .Select .Select .Columns .Single() .Expression .AsConstant .Literal .AsNumericLiteral .Value); Assert.AreEqual(3, select .SetOperators[1] .Select .Select .Columns .Single() .Expression .AsConstant .Literal .AsNumericLiteral .Value); }