public void TestBasicColumnReference()
{
var ctx = new Machine().Initialize();
var table = new TableMeta()
{
Name = "table"
};
Context.AddColumn(new ColumnMeta()
{
Name = "a", Type = ColumnType.Number
}, table);
ctx.AddTable(table);
var input = "table.a";
var parser = new Parser();
var reference = parser.ParseReference(input, 0, ctx, new SelectStatement(), new Parser.ReferenceFlags()
{
ResolveReferences = true
});
var expected = new ColumnReference()
{
Column = "a", Table = "table", InputLength = input.Length
};
Assert.AreEqual(reference, expected);
}
public void TestNamedExpression()
{
var input = "table.a as name FROM";
var ctx = new Machine().Initialize();
var table = new TableMeta()
{
Name = "table"
};
Context.AddColumn(new ColumnMeta()
{
Name = "a", Type = ColumnType.Number
}, table);
ctx.AddTable(table);
var parser = new Parser();
var result = parser.ParseExpression(input, 0, ctx, new SelectStatement(), new Parser.ExpressionFlags()
{
IdentifierAllowed = true
}, true, false);
Assert.IsNotNull(result.Identifier);
Assert.AreEqual(result.Identifier, "name");
}
public void TestReferenceOnlyExpression()
{
var input = "table.a";
var ctx = new Machine().Initialize();
var table = new TableMeta()
{
Name = "table"
};
Context.AddColumn(new ColumnMeta()
{
Name = "a", Type = ColumnType.Number
}, table);
ctx.AddTable(table);
var parser = new Parser();
var result = parser.ParseExpression(input, 0, ctx, new SelectStatement(), new Parser.ExpressionFlags(), true, false);
Assert.IsTrue(result.IsOnlyReference());
}
public void TestNullExpression()
{
var ctx = new Machine().Initialize();
var table = new TableMeta()
{
Name = "table"
};
Context.AddColumn(new ColumnMeta()
{
Name = "a", Type = ColumnType.Number
}, table);
ctx.AddTable(table);
var input = "NULL";
var result = new Parser().ParseExpression(input, 0, ctx, new SelectStatement(), new Parser.ExpressionFlags(), true, false);
Assert.AreEqual(result.Type, Expression.ExpressionType.Unknown);
Assert.IsTrue(result.Nodes.Count == 1);
Assert.AreEqual(result.Nodes[0].Kind, Expression.NodeKind.Null);
}
public void TestOrderByMultipleClauses()
{
var input = "SELECT * FROM a ORDER BY b desc, c";
var ctx = new Machine().Initialize();
var table = new TableMeta()
{
Name = "a"
};
Context.AddColumn(new ColumnMeta()
{
Name = "b", Type = ColumnType.Number
}, table);
Context.AddColumn(new ColumnMeta()
{
Name = "c", Type = ColumnType.Number
}, table);
ctx.AddTable(table);
var result = new Parser().ParseSelect(input, 0, ctx, new Parser.SelectFlags(), null);
var expected = new List <Ordering>()
{
new Ordering()
{
Kind = OrderingKind.Descending,
OrderExpression = new Expression()
{
FullText = " b",
Identifier = "a.b",
IsBoolean = false,
Type = Expression.ExpressionType.Number,
Nodes = new List <Expression.Node>()
{
new Expression.Node()
{
Kind = Expression.NodeKind.Reference,
ReferenceValue = new ColumnReference()
{
Column = "b",
Table = "a"
}
}
}
}
},
new Ordering()
{
Kind = OrderingKind.Ascending,
OrderExpression = new Expression()
{
FullText = " c",
Identifier = "a.c",
IsBoolean = false,
Type = Expression.ExpressionType.Number,
Nodes = new List <Expression.Node>()
{
new Expression.Node()
{
Kind = Expression.NodeKind.Reference,
ReferenceValue = new ColumnReference()
{
Column = "c",
Table = "a"
}
}
}
}
}
};
Assert.IsTrue(result.OutputOrder.SequenceEqual(expected));
}
public void TestSelectWithFunctionAndColumn()
{
var input = "select CURRENT_DATE(), a, table.b from table";
var ctx = new Machine().Initialize();
var table = new TableMeta()
{
Name = "table"
};
Context.AddColumn(new ColumnMeta()
{
Name = "a", Type = ColumnType.Number
}, table);
Context.AddColumn(new ColumnMeta()
{
Name = "b", Type = ColumnType.String
}, table);
ctx.AddTable(table);
var command = new Parser().ParseStatement(input, ctx);
Assert.IsTrue(command is SelectStatement);
var expected = new SelectStatement()
{
MainSource = new ColumnReference()
{
Table = "table", Identifier = "table", InputLength = 6
},
OriginalText = input
};
expected.OutputColumns.Add(new Expression()
{
Type = Expression.ExpressionType.Date,
FullText = "CURRENT_DATE()",
Identifier = "CURRENT_DATE()",
Nodes = new List <Expression.Node>
{
new Expression.Node()
{
Kind = Expression.NodeKind.Function, FunctionCall = new FunctionCall()
{
Name = "CURRENT_DATE", Arguments = new List <Expression>()
}
}
}
});
expected.OutputColumns.Add(new Expression()
{
Type = Expression.ExpressionType.Number,
FullText = "a",
Identifier = "a",
Nodes = new List <Expression.Node>
{
new Expression.Node()
{
Kind = Expression.NodeKind.Reference, ReferenceValue = new ColumnReference()
{
Column = "a", Table = "table"
}
}
}
});
expected.OutputColumns.Add(new Expression()
{
Type = Expression.ExpressionType.String,
FullText = "table.b",
Identifier = "table.b",
Nodes = new List <Expression.Node>
{
new Expression.Node()
{
Kind = Expression.NodeKind.Reference, ReferenceValue = new ColumnReference()
{
Column = "b", Table = "table"
}
}
}
});
Assert.AreEqual(command, expected);
}
