コード例 #1
0
        static AliasedItem MakeAliasedItem(string table, string column, string alias)
        {
            DbObject dbObject = MakeDbObject(table, column);

            AliasedItem aliasedItem = new AliasedItem(dbObject);

            if (alias != null)
            {
                aliasedItem.Alias = new Identifier(alias);
            }

            return(aliasedItem);
        }
コード例 #2
0
        public void TestSelectItem()
        {
            MacroScopeParser parser     = Factory.CreateParser("*");
            AliasedItem      selectItem = parser.selectItem();

            Assert.IsInstanceOfType(typeof(Wildcard), selectItem.Item);

            parser     = Factory.CreateParser("Author = Originator");
            selectItem = parser.selectItem();
            Assert.IsNotNull(selectItem);
            Identifier alias = selectItem.Alias;

            Assert.IsNotNull(alias);
            Assert.AreEqual("Author", alias.ID);
            Assert.AreEqual("Originator", TestUtil.Stringify(selectItem.Item));

            parser     = Factory.CreateParser("x = 1 + 2");
            selectItem = parser.selectItem();
            INode core = selectItem.Item;

            Assert.IsInstanceOfType(typeof(Expression), core);
            Assert.AreEqual("1 + 2", TestUtil.Stringify(core));

            parser     = Factory.CreateParser("x = y + z");
            selectItem = parser.selectItem();
            Assert.IsNotNull(selectItem);
            alias = selectItem.Alias;
            Assert.IsNotNull(alias);
            Assert.AreEqual("x", alias.ID);
            core = selectItem.Item;
            Assert.IsInstanceOfType(typeof(Expression), core);
            Assert.AreEqual("y + z", TestUtil.Stringify(core));

            parser     = Factory.CreateParser("address.*");
            selectItem = parser.selectItem();
            core       = selectItem.Item;
            Assert.IsInstanceOfType(typeof(TableWildcard), core);
            Assert.AreEqual("address.*", TestUtil.Stringify(core));

            parser     = Factory.CreateParser("1 + 2 * 3");
            selectItem = parser.selectItem();
            Assert.IsNotNull(selectItem);
            Assert.IsNull(selectItem.Alias);
            core = selectItem.Item;
            Assert.IsInstanceOfType(typeof(Expression), core);
            Assert.AreEqual("1 + (2 * 3)", TestUtil.Stringify(core));
        }
コード例 #3
0
        QueryExpression CreateSelectDistrictHead()
        {
            AliasedItem columns = MakeAliasedItem("district", "district_id");

            columns.Add(MakeAliasedItem("district", "name", "district_name"));

            Table districtTable = new Table(new Identifier("district"));

            Table districtGeoTable = new Table(new Identifier("district_tags"));

            districtGeoTable.JoinType      = Join.Inner;
            districtGeoTable.JoinCondition = new Expression(
                MakeDbObject("district", "district_id"),
                ExpressionOperator.Equal,
                MakeDbObject("district_tags", "district_id"));
            districtTable.Add(districtGeoTable);

            QueryExpression queryExpression = new QueryExpression();

            queryExpression.SelectItems = columns;
            queryExpression.From        = new AliasedItem(districtTable);
            return(queryExpression);
        }
コード例 #4
0
        public void TestSelectExpr()
        {
            CheckSelect("select 1", "SELECT 1");
            CheckSelect("select +1", "SELECT 1");
            CheckSelect("select -1", "SELECT -1");
            CheckSelect("select 1.5", "SELECT 1.5");
            CheckSelect("select 1e4", "SELECT 10000");
            CheckSelect("select 3e-2", "SELECT 0.03");
            CheckSelect("select 0xa", "SELECT 10");
            CheckSelect("select 1 + 2", "SELECT 1 + 2");
            CheckSelect("select (1 + 2)", "SELECT 1 + 2");
            CheckSelect("select (1 * 2) + (3 * 4)", "SELECT (1 * 2) + (3 * 4)");
            CheckSelect("select (1 + 2) * (3 + 4)", "SELECT (1 + 2) * (3 + 4)");
            CheckSelect("select (((1 + 2)))", "SELECT 1 + 2");
            CheckSelect("select 42 as answer", "SELECT 42 AS answer");
            CheckSelect("SELECT #2007-07-11 16:30:00#", "SELECT 2007-07-11T16:30:00");
            CheckSelect("SELECT 2007-07-11T16:30:00");
            CheckSelect("SELECT 2007-07-11 16:30:00", "SELECT 2007-07-11T16:30:00");
            CheckSelect("SELECT TIMESTAMP '2007-07-11 16:30:00'");
            CheckSelect("select 42 as \"The Answer\"", "SELECT 42 AS \"The Answer\"");
            CheckSelect("SELECT [column name]");
            CheckSelect("SELECT sum(amount) AS \"bottom line\"\r\nFROM t");
            CheckSelect("SELECT N'kůň'");
            CheckSelect("SELECT n'kůň'", "SELECT N'kůň'");

            StringBuilder expected = new StringBuilder();

            expected.Append("SELECT Customers.CustomerID, Customers.CompanyName, ");
            expected.Append("Customers.Country, CASE Country\r\n");
            expected.Append("WHEN 'Germany' THEN '0049 ' + Phone\r\n");
            expected.Append("WHEN 'Mexico' THEN 'Fiesta ' + Phone\r\n");
            expected.Append("WHEN 'UK' THEN 'Black Pudding (Yuk!) ' + Phone\r\n");
            expected.Append("ELSE Phone\r\nEND AS Phone\r\nFROM Customers");
            CheckSelect(@"SELECT 
 Customers.CustomerID
 , Customers.CompanyName
 , Customers.Country
 , CASE Country
    WHEN 'Germany' 
     THEN '0049 ' + Phone
    WHEN 'Mexico'
     THEN 'Fiesta ' + Phone
    WHEN 'UK'
     THEN 'Black Pudding (Yuk!) ' + Phone
     ELSE Phone
     END AS Phone
FROM 
 Customers", expected.ToString());

            SelectStatement statement = Factory.CreateStatement("select 1 * 2 + 3")
                                        as SelectStatement;

            Assert.IsNotNull(statement);

            QueryExpression queryExpression = statement.SingleQueryExpression;

            Assert.IsNotNull(queryExpression);
            Assert.IsNull(queryExpression.Top);
            Assert.IsFalse(queryExpression.Distinct);

            AliasedItem item = queryExpression.SelectItems;

            Assert.IsNotNull(item);
            Assert.IsFalse(item.HasNext);

            Expression expression = item.Item as Expression;

            Assert.IsNotNull(expression);

            ExpressionOperator expressionOperator = expression.Operator;

            Assert.IsNotNull(expressionOperator);
            Assert.AreEqual("+", expressionOperator.Value);

            CheckSelect("select 18/2/3", "SELECT (18 / 2) / 3");
        }