static void Main(string[] args)
{
string lQuery = "SELECT Jmeno, Prijmeni FROM Osoba, Film WHERE Stat LIKE 'Kanada' OR Rok_natoceni >1995 UNION " +
"(SELECT Jmeno, Prijmeni FROM Uzivatel WHERE Jmeno = 'ads' AND Prijmeni = 'asd');";
string lQuery2 = "SElect jmeno, nazev_cz FROM Osoba os JOIN Osoba_Film osf ON os.idO = osf.Osoba_idO JOIN Film f ON f.idF = osf.Film_idF Where f.Rok_natoceni > 1995;";
string lQuery1 = "select * from table1 t1, t2 where t1.neco = 1";
string text = ReadFile($@"C:\Users\Lukáš\Desktop\doc\Workload_bp.txt");
StringReader reader = new StringReader(text);
AntlrInputStream input = new AntlrInputStream(reader);
TSqlLexer lexer = new TSqlLexer(new CaseChangingCharStream(input, true));
CommonTokenStream tokens = new CommonTokenStream(lexer);
TSqlParser parser = new TSqlParser(tokens);
TSqlParser.Tsql_fileContext Tsql_fileContext1 = parser.tsql_file();
//Console.WriteLine("Tsql_fileContext1.ChildCount = " + Tsql_fileContext1.ChildCount.ToString());
Antlr4.Runtime.Tree.ParseTreeWalker walker = new Antlr4.Runtime.Tree.ParseTreeWalker();
AntlrTsqlListener listener = new AntlrTsqlListener();
walker.Walk(listener, Tsql_fileContext1);
foreach (var nTable in listener.AnalyzedWorkload)
{
Console.WriteLine("Tabulka " + nTable.Name);
foreach (var nColumn in nTable.Columns)
{
foreach (var nCondition in nColumn.Conditions)
{
Console.WriteLine($" col { nCondition.ColumnName} operator { nCondition.Operator} val {nCondition.Value}");
}
}
}
Console.ReadKey();
}
public Parser()
{
// TODO: create factories to abstract the version
var initialQuotedIdenfifiers = false;
_scriptParser = new TSql130Parser(initialQuotedIdenfifiers);
}
} // End Sub LexerTest
static void WalkerTest(string text)
{
try
{
System.IO.StringReader reader = new System.IO.StringReader(text);
Antlr4.Runtime.AntlrInputStream input = new Antlr4.Runtime.AntlrInputStream(reader);
TSqlLexer lexer = new TSqlLexer(input);
Antlr4.Runtime.CommonTokenStream tokens = new Antlr4.Runtime.CommonTokenStream(lexer);
TSqlParser parser = new TSqlParser(tokens);
// Specify our entry point
// TSqlParser.Query_specificationContext
TSqlParser.Tsql_fileContext fileContext = parser.tsql_file();
// Antlr4.Runtime.Tree.IParseTree root = (Antlr4.Runtime.Tree.IParseTree)fileContext;
// TSqlParser.Query_specificationContext tsqlParser.Tsql_fileContext fileContext = parser.tsql_file();
System.Console.WriteLine("fileContext.ChildCount = " + fileContext.ChildCount.ToString());
// Walk it and attach our listener
Antlr4.Runtime.Tree.ParseTreeWalker walker = new Antlr4.Runtime.Tree.ParseTreeWalker();
// AntlrTsqListener listener = new AntlrTsqListener();
EverythingListener listener = new EverythingListener();
walker.Walk(listener, fileContext);
}
catch (System.Exception e)
{
System.Console.WriteLine(e.Message);
}
} // End Sub WalkerTest
} // End Sub WalkerTest
static void VisitorTest(string text)
{
try
{
System.IO.StringReader reader = new System.IO.StringReader(text);
Antlr4.Runtime.AntlrInputStream input = new Antlr4.Runtime.AntlrInputStream(reader);
TSqlLexer lexer = new TSqlLexer(input);
Antlr4.Runtime.CommonTokenStream tokens = new Antlr4.Runtime.CommonTokenStream(lexer);
TSqlParser parser = new TSqlParser(tokens);
//Specify our entry point
// TSqlParser.Query_specificationContext
TSqlParser.Tsql_fileContext fileContext = parser.tsql_file();
System.Console.WriteLine("fileContext.ChildCount = " + fileContext.ChildCount.ToString());
SqlVisitor vis = new SqlVisitor();
string s = vis.Visit(fileContext);
System.Console.WriteLine(s);
}
catch (System.Exception e)
{
System.Console.WriteLine(e.Message);
}
} // End Sub VisitorTest
public void load_string(string str)
{
var inputStream = new AntlrInputStream(str);
var lexer = new TSqlLexer(inputStream);
var commonTokenStream = new CommonTokenStream(lexer);
var parser = new TSqlParser(commonTokenStream);
if (!noerrorlistener)
{
parser.RemoveErrorListeners();
parser.AddErrorListener(new ParserErrorListener());
}
Type t = parser.GetType();
MethodInfo mi = t.GetMethod(start_rulename);
if (mi == null)
{
throw new ArgumentException("rulename " + start_rulename + " not found.");
}
ParserRuleContext graphContext = (ParserRuleContext)mi.Invoke(parser, new object[] { });
//ParserRuleContext graphContext = parser.tsql_file();
var token_names = parser.TokenNames;
var rule_names = parser.RuleNames;
var tree_parser = new TreeParser(token_names, rule_names);
root = tree_parser.parse(graphContext);
}
static void ParseDDLClause(string input)
{
AntlrInputStream inputStream = new AntlrInputStream(input);
TSqlLexer lexer = new TSqlLexer(inputStream);
CommonTokenStream tokens = new CommonTokenStream(lexer);
TSqlParser parser = new TSqlParser(tokens);
var errorHandler = new SyntaxErrorListener();
parser.AddErrorListener(errorHandler);
var parseTree = parser.ddl_clause();
ParseTreeWalker walker = new ParseTreeWalker();
TSqlParserListenerExtended loader = new TSqlParserListenerExtended(new SelectStatement());
loader.TokenStream = tokens;
walker.Walk(loader, parseTree);
Console.WriteLine("Parse Tree:");
Console.WriteLine(parseTree.ToStringTree(parser));
Console.WriteLine("Errors:");
foreach (var error in errorHandler.Errors)
{
Console.WriteLine(error.Message + " at position " + error.Line.ToString() + ":" + error.CharPositionInLine.ToString());
}
Console.Write("Press enter key to continue");
Console.ReadLine();
}
static public void TestParsing(string sql, Func <TSqlParser, ParserRuleContext> parse)
{
TSqlParser parser = TSqlUtilities.GetParser(sql);
parser.AddErrorListener(new ErrorListener());
var parsed = parse(parser);
Assert.AreEqual(0, parser.NumberOfSyntaxErrors);
Assert.AreEqual(sql.Length - 1, parsed.Stop.StopIndex);
}
public static IEnumerable <TableInfo> FromFolder(TSqlParser parser, string folderPath)
{
foreach (var file in Directory.GetFiles(folderPath, "*.sql", SearchOption.AllDirectories))
{
foreach (var info in FromFile(parser, file))
{
yield return(info);
}
}
}
public ModelWrapper(SqlServerVersion version, string directory, string refactorLog, string preScript, string postScript)
{
_version = version;
_directory = directory;
_refactorLog = refactorLog;
_preScript = preScript;
_postScript = postScript;
_model = GetModel();
_parser = GetParser();
FillModel();
}
private void Boo(string input)
{
Debug.WriteLine("Boo");
AntlrInputStream antlrInput = new AntlrInputStream(input);
TSqlLexer lexer = new TSqlLexer(antlrInput);
CommonTokenStream tokens = new CommonTokenStream(lexer);
TSqlParser parser = new TSqlParser(tokens);
TSqlParserListenerExtended listener = new TSqlParserListenerExtended();
parser.search_condition().EnterRule(listener);
}
public ModelWrapper(SqlServerVersion version, string directory, string refactorLog, string preScript, string postScript, List <DacReference> ssdtReferences)
{
_version = version;
_directory = directory;
_refactorLog = refactorLog;
_preScript = preScript;
_postScript = postScript;
_model = GetModel();
_parser = GetParser();
ModelMessages = FillModel();
}
private FrostIDMLStatement GetDMLStatement(string input, string databaseName)
{
FrostIDMLStatement result = null;
TSqlParserListenerExtended loader;
var sqlStatement = string.Empty;
if (HasParticipant(input))
{
sqlStatement = RemoveParticipantKeyword(input);
}
else
{
sqlStatement = input;
}
AntlrInputStream inputStream = new AntlrInputStream(sqlStatement);
TSqlLexer lexer = new TSqlLexer(inputStream);
CommonTokenStream tokens = new CommonTokenStream(lexer);
TSqlParser parser = new TSqlParser(tokens);
var parseTree = parser.dml_clause();
ParseTreeWalker walker = new ParseTreeWalker();
loader = new TSqlParserListenerExtended(GetDMLStatementType(sqlStatement), sqlStatement);
loader.TokenStream = tokens;
walker.Walk(loader, parseTree);
if (loader.DMLStatement is InsertStatement)
{
var item = loader.DMLStatement as InsertStatement;
item.Participant = GetParticipant(GetParticipantString(input));
item.ParticipantString = GetParticipantString(input);
item.DatabaseName = databaseName;
if (item.Participant is null)
{
item.Participant = new Participant(_process.GetLocation());
}
result = item;
}
else if (loader.DMLStatement is UpdateStatement)
{
var item = loader.DMLStatement as UpdateStatement;
item.DatabaseName = databaseName;
item.SetProcess(_process);
result = item as FrostIDMLStatement;
}
else
{
result = loader.DMLStatement;
}
return(result);
}
public static IParseTree ParseTree(string input)
{
ICharStream Stream = CharStreams.fromstring(input);
ITokenSource Lexer = new TSqlLexer(Stream, TextWriter.Null, TextWriter.Null);
ITokenStream Tokens = new CommonTokenStream(Lexer);
TSqlParser Parser = new TSqlParser(Tokens, TextWriter.Null, TextWriter.Null)
{
BuildParseTree = true
};
IParseTree tree = Parser.tsql_file();
return(tree);
}
private void Bar(string input)
{
Debug.WriteLine("Bar");
AntlrInputStream inputStream = new AntlrInputStream(input);
TSqlLexer lexer = new TSqlLexer(inputStream);
CommonTokenStream tokens = new CommonTokenStream(lexer);
TSqlParser parser = new TSqlParser(tokens);
var parseTree = parser.select_statement();
ParseTreeWalker walker = new ParseTreeWalker();
TSqlParserListenerExtended loader = new TSqlParserListenerExtended();
walker.Walk(loader, parseTree);
}
/// <summary>
/// Parses the TSQL.
/// </summary>
/// <param name="input">The input.</param>
/// <param name="listener">The listener.</param>
private static void ParseTSQL(string input, IParseTreeListener listener)
{
ICharStream Stream = CharStreams.fromstring(input);
ITokenSource Lexer = new TSqlLexer(Stream, TextWriter.Null, TextWriter.Null);
ITokenStream Tokens = new CommonTokenStream(Lexer);
TSqlParser Parser = new TSqlParser(Tokens, TextWriter.Null, TextWriter.Null)
{
BuildParseTree = true
};
IParseTree tree = Parser.tsql_file();
ParseTreeWalker.Default.Walk(listener, tree);
}
public SqlFormatter()
{
this.parser = new TSql150Parser(false);
this.generator = new Sql150ScriptGenerator(new SqlScriptGeneratorOptions
{
KeywordCasing = KeywordCasing.Lowercase,
IncludeSemicolons = true,
NewLineBeforeFromClause = true,
NewLineBeforeOrderByClause = true,
NewLineBeforeWhereClause = true,
AlignClauseBodies = false,
IndentationSize = 2
});
}
private TableInfo GetTableInfo(string script)
{
var input = new AntlrInputStream(script);
var caseChangingStream = new CaseChangingCharStream(input, true);
var lexer = new TSqlLexer(caseChangingStream);
var tokens = new CommonTokenStream(lexer);
var parser = new TSqlParser(tokens);
var tree = parser.tsql_file();
var walker = new ParseTreeWalker();
var listener = new SqlListener();
walker.Walk(listener, tree);
return(listener.TableInfo);
}
private void ParseInput(string input)
{
AntlrInputStream inputStream = new AntlrInputStream(input);
TSqlLexer sqlLexer = new TSqlLexer(inputStream);
CommonTokenStream commonTokenStream = new CommonTokenStream(sqlLexer);
TSqlParser sqlParser = new TSqlParser(commonTokenStream);
TSqlParserListenerExtended listener = new TSqlParserListenerExtended();
TSqlParser.ExpressionContext expressionContext = sqlParser.expression();
//TSqlVisitor visitor = new TSqlVisitor();
//visitor.Visit(expressionContext);
MessageBox.Show("Done");
}
private static TSqlFragment GetAbstractSyntaxTree(string script)
{
using (TextReader textReader = new StringReader(script))
{
TSqlParser parser = GetTSqlParser(true);
TSqlFragment rootFragment = parser.Parse(textReader, out IList <ParseError> parsingErrors); // Get the parse tree
// if we could not parse the SQL we will throw an exception. Better here than on the server
if (parsingErrors.Count > 0)
{
throw new ParameterizationParsingException(parsingErrors[0].Line, parsingErrors[0].Column, parsingErrors[0].Message);
}
return(rootFragment);
}
}
public void inserted_id()
{
var sql = @"inserted.id";
var scanner = new TSqlScanner(sql);
var parser = new TSqlParser(scanner);
var expr = parser.ParseMeetObjectId();
new ObjectIdSqlCodeExpr()
{
RemoteServer = string.Empty,
DatabaseName = string.Empty,
SchemaName = "inserted",
ObjectName = "id"
}.ToExpectedObject().ShouldEqual(expr);
}
public static IEnumerable <TableInfo> FromFile(TSqlParser parser, string sqlFilePath)
{
using (var reader = new StreamReader(sqlFilePath))
{
IList <ParseError> errors;
var result = parser.Parse(reader, out errors);
var script = result as TSqlScript;
foreach (var ts in script.Batches)
{
foreach (var st in ts.Statements.OfType <CreateTableStatement>())
{
yield return(new TableInfo(st));
}
}
}
}
public void ProcessWorkload(string aScriptPath, EventHandler <string> aOnAnalyzingError)
{
string lText = ReadFile(aScriptPath);
StringReader lReader = new StringReader(lText);
AntlrInputStream lInput = new AntlrInputStream(lReader);
TSqlLexer lLexer = new TSqlLexer(new CaseChangingCharStream(lInput, true));
CommonTokenStream lTokens = new CommonTokenStream(lLexer);
TSqlParser lParser = new TSqlParser(lTokens);
TSqlParser.Tsql_fileContext Tsql_fileContext1 = lParser.tsql_file();
Antlr4.Runtime.Tree.ParseTreeWalker lWalker = new Antlr4.Runtime.Tree.ParseTreeWalker();
AntlrTsqlListener lListener = new AntlrTsqlListener();
lListener.OnAnalyzingError += aOnAnalyzingError;
lWalker.Walk(lListener, Tsql_fileContext1);
Tables = lListener.AnalyzedWorkload;
}
private static TSqlParser GetSqlParser(int compatabilityLevel)
{
compatabilityLevel = CompatabilityLevel.Validate(compatabilityLevel);
var fullyQualifiedName = string.Format("Microsoft.SqlServer.TransactSql.ScriptDom.TSql{0}Parser", compatabilityLevel);
TSqlParser parser = null;
foreach (var asm in AppDomain.CurrentDomain.GetAssemblies())
{
var parserType = asm.GetType(fullyQualifiedName);
if (parserType != null)
{
parser = (TSqlParser)Activator.CreateInstance(parserType, new object[] { true });
break;
}
}
return(parser ?? new TSql120Parser(true));
}
static void ParseInput(string input)
{
AntlrInputStream inputStream = new AntlrInputStream(input);
TSqlLexer lexer = new TSqlLexer(inputStream);
CommonTokenStream tokens = new CommonTokenStream(lexer);
TSqlParser parser = new TSqlParser(tokens);
var errorHandler = new SyntaxErrorListener();
parser.AddErrorListener(errorHandler);
var parseTree = parser.dml_clause();
ParseTreeWalker walker = new ParseTreeWalker();
TSqlParserListenerExtended loader = new TSqlParserListenerExtended(new SelectStatement());
loader.TokenStream = tokens;
walker.Walk(loader, parseTree);
Console.WriteLine("Parse Tree:");
Console.WriteLine(parseTree.ToStringTree(parser));
Console.WriteLine("Errors:");
foreach (var error in errorHandler.Errors)
{
Console.WriteLine(error.Message + " at position " + error.Line.ToString() + ":" + error.CharPositionInLine.ToString());
}
if (input.Contains("SELECT"))
{
var selectStatement = loader.GetStatementAsSelect();
var text = JsonConvert.SerializeObject(selectStatement);
Console.WriteLine("Review Parse. Press any key to continue.");
Console.ReadLine();
Console.WriteLine(text);
Console.WriteLine("Executing Generated Plan");
GeneratePlan(selectStatement);
}
Console.Write("Press enter key to continue");
Console.ReadLine();
}
private void ParseListener(string input)
{
TSqlLexer lexer = new TSqlLexer(new AntlrInputStream(input));
CommonTokenStream tokens = new CommonTokenStream(lexer);
TSqlParser parser = new TSqlParser(tokens);
TSqlParser.Select_statementContext selectStatement = new TSqlParser.Select_statementContext(parser.Context, 0);
TSqlParser.Select_list_elemContext selectElements = new TSqlParser.Select_list_elemContext(parser.Context, 0);
TSqlParser.Select_listContext selectListContext = new TSqlParser.Select_listContext(parser.Context, 0);
TSqlParser.Sql_clauseContext sqlClauseContext = new TSqlParser.Sql_clauseContext(parser.Context, 0);
TSqlParser.Sql_clausesContext clasesContext = new TSqlParser.Sql_clausesContext(parser.Context, 0);
ParseTreeWalker walker = new ParseTreeWalker();
TSqlParserListenerExtended listener = new TSqlParserListenerExtended();
walker.Walk(listener, selectStatement);
walker.Walk(listener, selectListContext);
walker.Walk(listener, selectElements);
walker.Walk(listener, sqlClauseContext);
walker.Walk(listener, clasesContext);
}
public TSqlParserInternal(TransactSqlVersion tsqlParserVersion, bool initialQuotedIdentifiers)
{
switch (tsqlParserVersion)
{
case TransactSqlVersion.Version80:
_parser = new TSql80Parser(initialQuotedIdentifiers);
break;
case TransactSqlVersion.Version90:
_parser = new TSql90Parser(initialQuotedIdentifiers);
break;
case TransactSqlVersion.Version100:
_parser = new TSql100Parser(initialQuotedIdentifiers);
break;
case TransactSqlVersion.Version110:
_parser = new TSql110Parser(initialQuotedIdentifiers);
break;
case TransactSqlVersion.Version120:
_parser = new TSql120Parser(initialQuotedIdentifiers);
break;
case TransactSqlVersion.Version130:
_parser = new TSql130Parser(initialQuotedIdentifiers);
break;
case TransactSqlVersion.Version140:
_parser = new TSql140Parser(initialQuotedIdentifiers);
break;
case TransactSqlVersion.Version150:
_parser = new TSql150Parser(initialQuotedIdentifiers);
break;
default:
throw new ArgumentException(nameof(tsqlParserVersion));
}
}
private void Boom(string input)
{
Debug.WriteLine("Boom");
AntlrInputStream inputStream = new AntlrInputStream(input);
TSqlLexer lexer = new TSqlLexer(inputStream);
CommonTokenStream tokens = new CommonTokenStream(lexer);
TSqlParser parser = new TSqlParser(tokens);
// these all appear to work in some way
var parseTree = parser.dml_clause();
//var parseTree = parser.query_specification();
//var parseTree = parser.query_expression();
ParseTreeWalker walker = new ParseTreeWalker();
TSqlParserListenerExtended loader = new TSqlParserListenerExtended();
walker.Walk(loader, parseTree);
Debug.WriteLine("---");
Debug.WriteLine(parseTree.ToStringTree(parser));
var item = lexer.Vocabulary;
Debug.WriteLine("");
}
private FrostIDDLStatement GetDDLStatement(string input, string databaseName)
{
FrostIDDLStatement result = null;
TSqlParserListenerExtended loader;
var sqlStatement = string.Empty;
if (HasParticipant(input))
{
sqlStatement = RemoveParticipantKeyword(input);
}
else
{
sqlStatement = input;
}
AntlrInputStream inputStream = new AntlrInputStream(sqlStatement);
TSqlLexer lexer = new TSqlLexer(inputStream);
CommonTokenStream tokens = new CommonTokenStream(lexer);
TSqlParser parser = new TSqlParser(tokens);
var parseTree = parser.ddl_clause();
ParseTreeWalker walker = new ParseTreeWalker();
loader = new TSqlParserListenerExtended(GetDDLStatementType(sqlStatement), sqlStatement);
loader.TokenStream = tokens;
walker.Walk(loader, parseTree);
if (loader.IsStatementCreateTable())
{
result = loader.GetStatementAsCreateTable();
}
if (loader.IsStatementCreateDatabase())
{
result = loader.GetStatementAsCreateDatabase();
}
return(result);
}
public AnalyzerServices(TSqlParser parser)
{
this.parser = parser;
}
public FragmentBuilder(int compatabilityLevel)
{
parser = GetSqlParser(CompatabilityLevel.Validate(compatabilityLevel));
}
