public void ObjectRef()
{
var dot = new Token("dot", ".");
var text = new Text("Text", ".+");
var root = new Def("ObjectRef", text, new Optional(dot, text), new Optional(dot, text));
Grammar grammar = new Grammar
{
StringQuote = '\'',
Root = root
};
string actual = GenerateAndBuildParser(grammar, "abc");
Assert.That(actual, Is.EqualTo(@"
ObjectRef
Text - abc"));
actual = GenerateAndBuildParser(grammar, "abc.def");
Assert.That(actual, Is.EqualTo(@"
ObjectRef
Text - abc
Dot
Text - def"));
actual = GenerateAndBuildParser(grammar, "abc.def.ghi");
Assert.That(actual, Is.EqualTo(@"
ObjectRef
Text - abc
Dot
Text - def
Dot
Text - ghi"));
}
public SqlGrammar()
{
var dot = new Token("dot", ".");
var star = new Token("star", "*");
var equalTo = new Token("equalTo", "=");
var comma = new Token("comma", ",");
var openParen = new Token("openParen", "(");
var closeParen = new Token("closeParen", ")");
var whitespace1 = new Token("whitespace", " ");
var whitespace2 = new Token("whitespace", "\t");
var whitespace3 = new Token("whitespace", "\n");
var whitespace4 = new Token("whitespace", "\r");
var openSquare = new Token("openSquare", "[");
var closeSquare = new Token("closeSquare", "]");
var _select = new Token("select");
var _from = new Token("from");
var _distinct = new Token("distinct");
var _top = new Token("top");
var _inner = new Token("inner");
var _left = new Token("left");
var _right = new Token("right");
var _outer = new Token("outer");
var _join = new Token("join");
var _on = new Token("on");
var _as = new Token("as");
var _count = new Token("count");
var _min = new Token("min");
var _max = new Token("max");
var _avg = new Token("avg");
var _where = new Token("where");
var _cross = new Token("cross");
var _order = new Token("order");
var _by = new Token("by");
var _with = new Token("with");
var _nolock = new Token("nolock");
var _like = new Token("like");
var integer = new Text("Integer", "[0-9]+");
var text = new Text("Text", ".+");
var objectRef = new Def("ObjectRef", text, new Optional(dot, text), new Optional(dot, text));
var table = new Def("Table", text, new Optional(_as), new Optional(text));
var joinDef = new Def("JoinDef", new Optional(new OneOf(_inner, _left, _right)), new Optional(_outer), _join, table, _on, objectRef, equalTo, objectRef);
var starOrObjectRef = new Def("StarOrObjectRef", new OneOf(star, objectRef));
var aggregate = new Def("Aggregate", new Def("Agg", new OneOf(_count, _min, _max, _avg)), openParen, starOrObjectRef, closeParen);
var objectRefOrAggregate = new Def("ObjectRefOrAggregate", new OneOf(objectRef, aggregate));
var selectField = new Def("SelectField", objectRefOrAggregate, new Optional(_as), new Optional(text));
var commaSelectField = new Def("CommaSelectField", comma, selectField);
var selectFieldList = new Def("SelectFieldList", selectField, new ZeroOrMore(commaSelectField));
var selectFields = new Def("SelectFields", new OneOf(star, selectFieldList));
var topX = new Def("TopX", _top, integer);
_root = new Def("SelectStatement", _select, new Optional(topX), new Optional(_distinct), selectFields, _from, table, new ZeroOrMore(joinDef));
}
public void StarOrObjectRef()
{
var dot = new Token("dot", ".");
var text = new Text("Text", ".+");
var star = new Token("star", "*");
var _space = new Token("whitespace", " ");
var objectRef = new Def("ObjectRef", text, new Optional(dot, text), new Optional(dot, text));
var root = new Def("StarOrObjectRef", new OneOf(star, objectRef));
Grammar grammar = new Grammar
{
StringQuote = '\'',
Root = root,
IgnoreTokens = new[] { _space }
};
string actual = GenerateAndBuildParser(grammar, "*");
Assert.That(actual, Is.EqualTo(@""));
}
public void Table()
{
var _as = new Token("as");
var _space = new Token("WhiteSpace", " ");
var text = new Text("Text", ".+");
var root = new Def("Table", text, new Optional(_as), new Optional(text));
Grammar grammar = new Grammar
{
StringQuote = '\'',
Root = root,
IgnoreTokens = new[] { _space }
};
string actual = GenerateAndBuildParser(grammar, "abc");
Assert.That(actual, Is.EqualTo(@"
Table
Text - abc"));
actual = GenerateAndBuildParser(grammar, "abc ABC");
Assert.That(actual, Is.EqualTo(@"
Table
Text - abc
Text - ABC"));
actual = GenerateAndBuildParser(grammar, "abc as ABC");
Assert.That(actual, Is.EqualTo(@"
Table
Text - abc
As
Text - ABC"));
}
public Grammar BuildGrammar(Node<GrammarGrammar.NodeType> parent)
{
Grammar grammar = new Grammar();
var nameNode = parent.Children.FirstOrDefault(x => x.NodeType == GrammarGrammar.NodeType.Text);
if (nameNode != null)
{
grammar.Name = nameNode.Text;
}
List<Token> punctuation = GetTokens(parent.Children.FirstOrDefault(x => x.NodeType == GrammarGrammar.NodeType.Punctuation));
List<Token> keywords = GetTokens(parent.Children.FirstOrDefault(x => x.NodeType == GrammarGrammar.NodeType.Keywords));
List<Token> texts = GetTokens(parent.Children.FirstOrDefault(x => x.NodeType == GrammarGrammar.NodeType.Texts));
grammar.Punctuation = punctuation.Select(x => new Token(x.Name, x.Text)).ToList();
grammar.Keywords = keywords.Select(x => new Token(x.Name, x.Text)).ToList();
grammar.Texts = texts.Select(x => new Token(x.Name, x.Text)).ToList();
List<string> ignoreNames = GetNames(parent.Children.FirstOrDefault(x => x.NodeType == GrammarGrammar.NodeType.Ignore));
List<string> discardNames = GetNames(parent.Children.FirstOrDefault(x => x.NodeType == GrammarGrammar.NodeType.Discard));
List<Def> defs = new List<Def>();
List<Node<GrammarGrammar.NodeType>> reversed = parent.Children.FirstOrDefault(x => x.NodeType == GrammarGrammar.NodeType.Defs).Children;
reversed.Reverse();
foreach (var def in reversed)
{
var textNode = def.Children.First(x => x.NodeType == GrammarGrammar.NodeType.Text);
var deff = new Def(textNode.Text);
defs.Add(deff);
foreach (var part in def.Children.Where(x => x.NodeType == GrammarGrammar.NodeType.Part))
{
Thing thing = null;
Thing thing2 = null;
var names = part.Children.Single(x => x.NodeType == GrammarGrammar.NodeType.Names);
if (names.Children.Last().NodeType == GrammarGrammar.NodeType.Plus
|| part.Children.Last().NodeType == GrammarGrammar.NodeType.Plus)
{
thing = thing2 = new OneOrMore();
}
else if (names.Children.Last().NodeType == GrammarGrammar.NodeType.Star
|| part.Children.Last().NodeType == GrammarGrammar.NodeType.Star)
{
thing = thing2 = new ZeroOrMore();
}
if (part.Children.First().NodeType == GrammarGrammar.NodeType.OpenSquare)
{
if (thing == null)
{
thing = thing2 = new Optional();
}
else
{
thing2 = new Optional();
thing.Children = new List<Thing>() { thing2 };
}
}
if (names.Children.Any(x => x.NodeType == GrammarGrammar.NodeType.Pipe))
{
if (thing == null)
{
thing = thing2 = new OneOf();
}
else
{
thing2 = new OneOf();
thing.Children = new List<Thing>() { thing2 };
}
}
List<Thing> things = new List<Thing>();
foreach (var name in names.Children.Where(x => x.NodeType == GrammarGrammar.NodeType.Text))
{
Thing childThing = null;
var token = grammar.Punctuation.SingleOrDefault(x => x.Name == name.Text);
if (token != null)
{
things.Add(token);
}
else
{
token = grammar.Keywords.SingleOrDefault(x => x.Name == name.Text);
if (token != null)
{
things.Add(token);
}
else
{
token = grammar.Texts.SingleOrDefault(x => x.Name == name.Text);
if (token != null)
{
things.Add(token);
}
else
{
var def2 = defs.SingleOrDefault(x => x.Name == name.Text);
if (def2 != null)
{
things.Add(def2);
}
else
{
throw new Exception();
}
}
}
}
}
if (thing == null)
{
deff.Children.AddRange(things);
}
else
{
thing2.Children = things;
deff.Children.Add(thing);
}
}
}
grammar.Root = defs.Last();
List<Token> ignoreTokens = new List<Token>();
List<string> discardThings = new List<string>();
ignoreTokens.AddRange(keywords.Where(x => ignoreNames.Contains(x.Name)));
ignoreTokens.AddRange(punctuation.Where(x => ignoreNames.Contains(x.Name)));
discardThings.AddRange(keywords.Where(x => discardNames.Contains(x.Name)).Select(x => x.Name));
discardThings.AddRange(punctuation.Where(x => discardNames.Contains(x.Name)).Select(x => x.Name));
discardThings.AddRange(defs.Where(x => discardNames.Contains(x.Name)).Select(x => x.Name));
grammar.IgnoreTokens = ignoreTokens.ToArray();
grammar.DiscardThings = discardThings.ToArray();
grammar.StringQuote = '\'';
return grammar;
}
