criteriatest.java

torque服务器源代码

        c.or(cn3.and(cn4));

        String expect =
            "SELECT  FROM INVOICE WHERE "
            + "((INVOICE.COST>='1000' AND INVOICE.COST<='2000') "
            + "OR (INVOICE.COST>='8000' AND INVOICE.COST<='9000'))";

        String result = null;
        try
        {
            result = BasePeer.createQueryString(c);
        }
        catch (TorqueException e)
        {
            fail("TorqueException thrown in BasePeer.createQueryString()");
        }

        assertEquals(expect, result);
    }

    /**
     * Test Criterion.setIgnoreCase().
     * As the output is db specific the test just prints the result to
     * System.out
     */
    public void testCriterionIgnoreCase()
    {
        Criteria myCriteria = new Criteria();

        Criteria.Criterion expected = myCriteria.getNewCriterion(
                "TABLE.COLUMN", (Object)"FoObAr", Criteria.LIKE);
        Criteria.Criterion result = expected.setIgnoreCase(true);
        assertEquals("Criterion mis-match after calling setIgnoreCase(true)",
                     expected.toString(), result.toString());
    }

    /**
     * Test that true is evaluated correctly.
     */
    public void testBoolean()
    {
        Criteria c = new Criteria().add("TABLE.COLUMN", true);

        String expect = "SELECT  FROM TABLE WHERE TABLE.COLUMN=1";

        String result = null;
        try
        {
            result = BasePeer.createQueryString(c);
        }
        catch (TorqueException e)
        {
            fail("TorqueException thrown in BasePeer.createQueryString()");
        }

        assertEquals(expect, result);

        // test the postgresql variation
        c = new Criteria();
        Criteria.Criterion cc =
            c.getNewCriterion("TABLE.COLUMN", Boolean.TRUE, Criteria.EQUAL);

        Configuration conf = new BaseConfiguration();
        conf.addProperty("driver", "org.postgresql.Driver");
        try
        {
            cc.setDB(DBFactory.create("org.postgresql.Driver"));
        }
        catch (Exception e)
        {
            fail("Exception thrown in DBFactory");
        }

        assertEquals("TABLE.COLUMN=1", cc.toString());
    }

    /**
     * testcase for addDate()
     */
    public void testAddDate()
    {
        Criteria c = new Criteria();
        c.addDate("TABLE.DATE_COLUMN", 2003, 0, 22);

        String expect = "SELECT  FROM TABLE WHERE TABLE.DATE_COLUMN='20030122000000'";

        String result = null;
        try
        {
            result = BasePeer.createQueryString(c);
        }
        catch (TorqueException e)
        {
            e.printStackTrace();
            fail("TorqueException thrown in BasePeer.createQueryString()");
        }
        assertEquals(expect, result);
    }

    /**
     * testcase for add(Date)
     */
    public void testDateAdd()
    {
        Calendar cal = Calendar.getInstance();
        cal.set(2003, 0, 22, 0, 0, 0);
        Date date = cal.getTime();
        Criteria c = new Criteria();
        c.add("TABLE.DATE_COLUMN", date);

        String expect = "SELECT  FROM TABLE WHERE TABLE.DATE_COLUMN='20030122000000'";

        String result = null;
        try
        {
            result = BasePeer.createQueryString(c);
        }
        catch (TorqueException e)
        {
            e.printStackTrace();
            fail("TorqueException thrown in BasePeer.createQueryString()");
        }
        assertEquals(expect, result);
    }

    public void testCurrentDate()
    {
        Criteria c = new Criteria()
                .add("TABLE.DATE_COLUMN", Criteria.CURRENT_DATE)
                .add("TABLE.TIME_COLUMN", Criteria.CURRENT_TIME);

        String expect = "SELECT  FROM TABLE WHERE TABLE.TIME_COLUMN=CURRENT_TIME AND TABLE.DATE_COLUMN=CURRENT_DATE";

        String result = null;
        try
        {
            result = BasePeer.createQueryString(c);
        }
        catch (TorqueException e)
        {
            e.printStackTrace();
            fail("TorqueException thrown in BasePeer.createQueryString()");
        }

        assertEquals(expect,result);
    }

    public void testCountAster()
    {
        Criteria c = new Criteria()
                .addSelectColumn("COUNT(*)")
                .add("TABLE.DATE_COLUMN", Criteria.CURRENT_DATE)
                .add("TABLE.TIME_COLUMN", Criteria.CURRENT_TIME);

        String expect = "SELECT COUNT(*) FROM TABLE WHERE TABLE.TIME_COLUMN=CURRENT_TIME AND TABLE.DATE_COLUMN=CURRENT_DATE";

        String result = null;
        try
        {
            result = BasePeer.createQueryString(c);
        }
        catch (TorqueException e)
        {
            e.printStackTrace();
            fail("TorqueException thrown in BasePeer.createQueryString()");
        }

        assertEquals(expect,result);

    }

    /**
     * This test case has been written to try out the fix applied to resolve
     * TRQS73 - i.e. ensuring that Criteria.toString() does not alter any limit
     * or offset that may be stored in the Criteria object.  This testcase
     * could actually pass without the fix if the database in use does not
     * support native limits and offsets.
     */
    public void testCriteriaToStringOffset()
    {
        Criteria c = new Criteria()
                .add("TABLE.DATE_COLUMN", Criteria.CURRENT_DATE)
                .setOffset(3)
                .setLimit(5);

        String toStringExpect = "Criteria:: TABLE.DATE_COLUMN<=>TABLE.DATE_COLUMN=CURRENT_DATE:  "
                + "\nCurrent Query SQL (may not be complete or applicable): "
                + "SELECT  FROM TABLE WHERE TABLE.DATE_COLUMN=CURRENT_DATE LIMIT 3, 5";

        String cString = c.toString();
        //System.out.println(cString);
        assertEquals(cString, toStringExpect);

        // Note that this is intentially the same as above as the behaviour is
        // only observed on subsequent invocations of toString().
        cString = c.toString();
        //System.out.println(cString);
        assertEquals(cString, toStringExpect);
    }

    /**
     * This test case has been written to try out the fix applied to resolve
     * TRQS73 - i.e. ensuring that Criteria.toString() does not alter any limit
     * or offset that may be stored in the Criteria object.  This testcase
     * could actually pass without the fix if the database in use does not
     * support native limits and offsets.
     */
    public void testCriteriaToStringLimit()
    {
        Criteria c = new Criteria()
                .add("TABLE.DATE_COLUMN", Criteria.CURRENT_DATE)
                .setLimit(5);

        String toStringExpect = "Criteria:: TABLE.DATE_COLUMN<=>TABLE.DATE_COLUMN=CURRENT_DATE:  "
                + "\nCurrent Query SQL (may not be complete or applicable): "
                + "SELECT  FROM TABLE WHERE TABLE.DATE_COLUMN=CURRENT_DATE LIMIT 5";

        String cString = c.toString();
        //System.out.println(cString);
        assertEquals(cString, toStringExpect);

        // Note that this is intentially the same as above as the behaviour is
        // only observed on subsequent invocations of toString().
        cString = c.toString();
        //System.out.println(cString);
        assertEquals(cString, toStringExpect);
    }

    /**
     * test for TRQS25
     */
/*
    public void testCriteriaAndString()
    {
        Criteria c = new Criteria()
                .add("TABLE.COLUMN1", "string")
                .and("TABLE.COLUMN2", "string", Criteria.LIKE);
    }
*/
}