adding support for *

Author: brunovcosta

README.md

@@ -31,7 +31,13 @@ This will return all the users in the `users.json` file.
 
 ## Supported SQL Syntax
 
-- [ ] `SELECT`:
+- [ ] `WITH`
+    - [ ] `RECURSIVE`
+
+- [ ] `SELECT`
+    - [ ] `ALL`
+    - [ ] `DISTINCT`
+    - [ ] `*`
     - [x] `FROM`
     - [x] `WHERE`
     - [x] `GROUP BY`

abstra_json_sql/apply.py

@@ -1,4 +1,4 @@
-from typing import List, Dict, Optional
+from typing import List, Dict, Optional, Union
 from .tables import ITablesSnapshot
 from .field_name import field_name, expression_name
 from .ast import (
@@ -11,6 +11,7 @@
     From,
     SelectField,
     Where,
+    Wildcard,
     GroupBy,
     FunctionCallExpression,
     Command,
@@ -22,7 +23,6 @@
     IsExpression,
     FalseExpression,
     TrueExpression,
-    Wildcard,
     OrderBy,
     MinusExpression,
     MultiplyExpression,
@@ -33,7 +33,6 @@
     GreaterThanOrEqualExpression,
     LessThanExpression,
     LessThanOrEqualExpression,
-    Wildcard,
     Limit,
 )
 from dataclasses import dataclass
@@ -355,6 +354,10 @@ def apply_expression(expression: Expression, ctx: dict):
                 raise ValueError(f"Unknown function: {expression.name}")
     elif isinstance(expression, NullExpression):
         return None
+    elif isinstance(expression, FalseExpression):
+        return False
+    elif isinstance(expression, TrueExpression):
+        return True
     elif isinstance(expression, IsExpression):
         left_value = apply_expression(expression.left, ctx)
         right_value = apply_expression(expression.right, ctx)
@@ -503,15 +506,20 @@ def has_aggregation_fields(fields: List[SelectField]) -> bool:
 
 
 def apply_select_fields(fields: List[SelectField], data: List[dict], ctx: dict):
-    return [
-        {
-            field_name(field) or field.expression: apply_expression(
-                field.expression, {**ctx, **row}
-            )
-            for field in fields
-        }
-        for row in data
-    ]
+    result = []
+    for row in data:
+        result_row = {}
+        for field in fields:
+            if isinstance(field.expression, Wildcard):
+                result_row.update(row)
+            elif isinstance(field.expression, Expression):
+                result_row[field_name(field)] = apply_expression(
+                    field.expression, {**ctx, **row}
+                )
+            else:
+                raise ValueError(f"Unsupported field type: {type(field)}")
+        result.append(result_row)
+    return result
 
 
 def apply_from(

abstra_json_sql/ast.py

@@ -172,7 +172,7 @@ class Having(Ast):
 
 @dataclass
 class SelectField(Ast):
-    expression: Expression
+    expression: Union[Expression, Wildcard]
     alias: Optional[str] = None
 
 
@@ -200,7 +200,7 @@ class Limit(Ast):
 
 @dataclass
 class Select(Command):
-    field_parts: List[Union[SelectField, Wildcard]]
+    field_parts: List[SelectField]
     from_part: Optional[From] = None
     where_part: Optional[Where] = None
     group_part: Optional[GroupBy] = None

abstra_json_sql/eval_test.py

@@ -499,3 +499,31 @@ def test_complete(self):
         ctx = {}
         result = eval_sql(code=code, tables=tables, ctx=ctx)
         self.assertEqual(result, [{"foo": 3, "count": 2}])
+
+    def test_select_wildcard(self):
+        code = "select * from bar"
+        tables = InMemoryTables(
+            tables=[
+                Table(
+                    name="bar",
+                    columns=[Column(name="foo", type="text")],
+                    data=[
+                        {"foo": "a"},
+                        {"foo": "b"},
+                        {"foo": None},
+                        {"foo": "c"},
+                    ],
+                )
+            ],
+        )
+        ctx = {}
+        result = eval_sql(code=code, tables=tables, ctx=ctx)
+        self.assertEqual(
+            result,
+            [
+                {"foo": "a"},
+                {"foo": "b"},
+                {"foo": None},
+                {"foo": "c"},
+            ],
+        )

abstra_json_sql/parser.py

@@ -274,7 +274,7 @@ def parse_fields(tokens: List[Token]) -> Tuple[List[SelectField], List[Token]]:
         if tokens[0].type == "keyword" and tokens[0].value.upper() == "FROM":
             break
         elif tokens[0].type == "wildcard":
-            fields.append(Wildcard())
+            fields.append(SelectField(Wildcard()))
             tokens = tokens[1:]
         elif tokens[0].type == "comma":
             tokens = tokens[1:]

abstra_json_sql/parser_test.py

@@ -38,7 +38,7 @@ def test_select_wildcard(self):
         self.assertEqual(
             ast,
             Select(
-                field_parts=[Wildcard()],
+                field_parts=[SelectField(Wildcard())],
                 from_part=From(
                     table="users",
                 ),