TABLE statement

mindsdb_sql_parser/ast/__init__.py

@@ -15,5 +15,6 @@
 from .drop import *
 from .create import *
 from .variable import *
+from .table import Table
 
 from .mindsdb.latest import Latest

mindsdb_sql_parser/ast/table.py

@@ -0,0 +1,73 @@
+from typing import Optional, List, Any
+
+from mindsdb_sql_parser.ast.base import ASTNode
+
+
+class Table(ASTNode):
+    """AST node representing a TABLE statement with optional ORDER BY, LIMIT, and OFFSET clauses.
+    https://dev.mysql.com/doc/refman/8.4/en/table.html
+
+    Args:
+        name: The name of the table (Identifier).
+        order_by: Optional list of ORDER BY terms.
+        limit: Optional LIMIT value (Constant).
+        offset: Optional OFFSET value (Constant).
+        *args: Additional positional arguments for ASTNode.
+        **kwargs: Additional keyword arguments for ASTNode.
+    """
+    def __init__(
+        self,
+        name: Any,
+        order_by: Optional[List[Any]] = None,
+        limit: Optional[Any] = None,
+        offset: Optional[Any] = None,
+        *args,
+        **kwargs
+    ):
+        super().__init__(*args, **kwargs)
+        self.name = name
+        self.order_by = order_by
+        self.limit = limit
+        self.offset = offset
+
+    def to_tree(self, *args, level: int = 0, **kwargs) -> str:
+        """Returns a string representation of the AST tree for this node.
+
+        Args:
+            level: Indentation level for pretty printing.
+            *args: Additional positional arguments.
+            **kwargs: Additional keyword arguments.
+
+        Returns:
+            str: The tree representation of the node.
+        """
+        ind = '  ' * level
+        out = f'{ind}Table(\n'
+        out += f'{ind}  name={self.name},\n'
+        if self.order_by:
+            out += f'{ind}  order_by={self.order_by},\n'
+        if self.limit:
+            out += f'{ind}  limit={self.limit},\n'
+        if self.offset:
+            out += f'{ind}  offset={self.offset},\n'
+        out += f'{ind})'
+        return out
+
+    def to_string(self, *args, **kwargs) -> str:
+        """Returns a SQL string representation of the TABLE statement.
+
+        Args:
+            *args: Additional positional arguments.
+            **kwargs: Additional keyword arguments.
+
+        Returns:
+            str: The SQL string representation.
+        """
+        s = f'TABLE {self.name}'
+        if self.order_by:
+            s += ' ORDER BY ' + ', '.join([o.to_string() for o in self.order_by])
+        if self.limit:
+            s += f' LIMIT {self.limit.to_string()}'
+        if self.offset:
+            s += f' OFFSET {self.offset.to_string()}'
+        return s

mindsdb_sql_parser/parser.py

@@ -103,6 +103,7 @@ class MindsDBParser(Parser):
        'update_agent',
        'create_index',
        'drop_index',
+       'table',
        )
     def query(self, p):
         return p[0]
@@ -2083,3 +2084,39 @@ def error(self, p, expected_tokens=None):
         )
         # don't raise exception
         return
+
+    # region TABLE https://dev.mysql.com/doc/refman/8.4/en/table.html
+    @_('TABLE identifier table_opt_order_by table_opt_limit table_opt_offset')
+    def table(self, p):
+        from mindsdb_sql_parser.ast.table import Table
+        return Table(
+            name=p.identifier,
+            order_by=p.table_opt_order_by,
+            limit=p.table_opt_limit,
+            offset=p.table_opt_offset
+        )
+
+    @_('empty')
+    def table_opt_order_by(self, p):
+        return None
+
+    @_('ORDER_BY ordering_terms')
+    def table_opt_order_by(self, p):
+        return p.ordering_terms
+
+    @_('empty')
+    def table_opt_limit(self, p):
+        return None
+
+    @_('LIMIT constant')
+    def table_opt_limit(self, p):
+        return p.constant
+
+    @_('empty')
+    def table_opt_offset(self, p):
+        return None
+
+    @_('OFFSET constant')
+    def table_opt_offset(self, p):
+        return p.constant
+    # endregion

tests/test_base_sql/test_misc_sql_queries.py

@@ -77,6 +77,14 @@ def test_autocommit(self):
         assert ast.to_tree() == expected_ast.to_tree()
         assert str(ast) == str(expected_ast)
 
+    def test_table_with_order_by_limit_offset(self):
+        sql = "TABLE my_table ORDER BY my_column LIMIT 10 OFFSET 5"
+        ast = parse_sql(sql)
+        assert isinstance(ast, Table)
+        assert ast.name.to_string() == 'my_table'
+        assert ast.order_by[0].field.to_string() == 'my_column'
+        assert ast.limit.value == 10
+        assert ast.offset.value == 5
 
 
 class TestMiscQueriesNoSqlite: