def checkNominal(self, statement, expected_dump=None):
     exp = QgsSQLStatement(statement)
     self.assertEqual(exp.hasParserError(), False)
     self.assertEqual(exp.parserErrorString(), "")
     if expected_dump is None:
         expected_dump = statement
     self.assertEqual(exp.dump(), expected_dump)
     self.assertEqual(exp.dump(), exp.rootNode().clone().dump())

 def testNominalSimple(self):
     statement = "SELECT a FROM t"
     self.checkNominal(statement)
     exp = QgsSQLStatement(statement)
     statement_node = exp.rootNode()
     self.assertEqual(statement_node.nodeType(), QgsSQLStatement.ntSelect)
     tables = statement_node.tables()
     self.assertEqual(len(tables), 1)
     table = tables[0]
     self.assertEqual(table.nodeType(), QgsSQLStatement.ntTableDef)
     self.assertEqual(table.name(), 't')
     self.assertEqual(table.alias(), '')
     columns = statement_node.columns()
     self.assertEqual(len(columns), 1)
     column = columns[0]
     self.assertEqual(column.nodeType(), QgsSQLStatement.ntSelectedColumn)
     column_ref = column.column()
     self.assertEqual(column.alias(), '')
     self.assertEqual(column_ref.nodeType(), QgsSQLStatement.ntColumnRef)
     self.assertEqual(column_ref.name(), 'a')
     self.assertEqual(column_ref.tableName(), '')

    def testBasicValidationCheck(self):
        exp = QgsSQLStatement("error")
        (b, errorMsg) = exp.doBasicValidationChecks()
        self.assertFalse(b)
        self.assertEqual(errorMsg, 'No root node')

        exp = QgsSQLStatement("SELECT c FROM t")
        (b, errorMsg) = exp.doBasicValidationChecks()
        self.assertTrue(b)
        self.assertEqual(errorMsg, '')

        exp = QgsSQLStatement("SELECT t.c FROM t ORDER BY t.c")
        (b, errorMsg) = exp.doBasicValidationChecks()
        self.assertTrue(b)
        self.assertEqual(errorMsg, '')

        exp = QgsSQLStatement("SELECT t.c FROM t t_alias")
        (b, errorMsg) = exp.doBasicValidationChecks()
        self.assertFalse(b)
        self.assertEqual(
            errorMsg, 'Table t is referenced by column c, but not selected in FROM / JOIN.')

        exp = QgsSQLStatement(
            "SELECT CAST(1 + foo(t_unknown.a) AS varchar) FROM t")
        (b, errorMsg) = exp.doBasicValidationChecks()
        self.assertFalse(b)
        self.assertEqual(
            errorMsg, 'Table t_unknown is referenced by column a, but not selected in FROM / JOIN.')

        exp = QgsSQLStatement("SELECT c FROM t WHERE t_unknown.a = 1")
        (b, errorMsg) = exp.doBasicValidationChecks()
        self.assertFalse(b)
        self.assertEqual(
            errorMsg, 'Table t_unknown is referenced by column a, but not selected in FROM / JOIN.')

        exp = QgsSQLStatement(
            "SELECT c FROM t JOIN t2 ON t.c1 = t2.c2 AND t3.c3 IS NOT NULL")
        (b, errorMsg) = exp.doBasicValidationChecks()
        self.assertFalse(b)
        self.assertEqual(
            errorMsg, 'Table t3 is referenced by column c3, but not selected in FROM / JOIN.')

        exp = QgsSQLStatement("SELECT c FROM t ORDER BY t_unknown.c")
        (b, errorMsg) = exp.doBasicValidationChecks()
        self.assertFalse(b)
        self.assertEqual(
            errorMsg, 'Table t_unknown is referenced by column c, but not selected in FROM / JOIN.')

 def checkError(self, statement):
     exp = QgsSQLStatement(statement)
     self.assertEqual(exp.hasParserError(), True)
     self.assertNotEqual(exp.parserErrorString(), '')
     self.assertEqual(exp.dump(), "(no root)")
     self.assertEqual(exp.rootNode(), None)