Merge pull request #69 from passren/0.7.4

0.7.4

Author: passren

.github/workflows/run-test.yaml

@@ -83,6 +83,6 @@ jobs:
         with:
           fetch-depth: 0
       - name: SonarCloud Scan
-        uses: SonarSource/sonarqube-scan-action@v5.3.1
+        uses: SonarSource/sonarqube-scan-action@v6.0.0
         env:
           SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}

pydynamodb/__init__.py

@@ -6,7 +6,7 @@
 if TYPE_CHECKING:
     from .connection import Connection
 
-__version__: str = "0.7.3"
+__version__: str = "0.7.4"
 
 # Globals https://www.python.org/dev/peps/pep-0249/#globals
 apilevel: str = "2.0"

pydynamodb/sql/common.py

@@ -92,7 +92,9 @@ class KeyWords:
         SPACE,
         LBRACKET,
         RBRACKET,
-    ) = map(Suppress, "(),;:.'\"`= []")
+        LCURLYBRACKET,
+        RCURLYBRACKET,
+    ) = map(Suppress, "(),;:.'\"`= []{}")
     STAR, QUESTION = "*", "?"
     SUPPRESS_QUOTE = (SINGLEQUOTE | BACKQUOTE | DOUBLEQUOTE).set_name("suppress_quote")
     QUOTE = one_of("' \" `").set_name("quote")
@@ -149,18 +151,23 @@ class KeyWords:
         FROM,
         WHERE,
         INSERT,
+        INTO,
+        VALUE,
         GLOBAL,
         PARTITION_KEY,
         SORT_KEY,
         HASH,
         RANGE,
         UPDATE,
+        SET,
+        REMOVE,
         DELETE,
         INDEX,
         REPLICA,
         ORDER_BY,
         LIMIT,
         AS,
+        RETURNING,
     ) = map(
         CaselessKeyword,
         [
@@ -172,18 +179,23 @@ class KeyWords:
             "FROM",
             "WHERE",
             "INSERT",
+            "INTO",
+            "VALUE",
             "GLOBAL",
             "PARTITION KEY",
             "SORT KEY",
             "HASH",
             "RANGE",
             "UPDATE",
+            "SET",
+            "REMOVE",
             "DELETE",
             "INDEX",
             "REPLICA",
             "ORDER BY",
             "Limit",
             "AS",
+            "RETURNING",
         ],
     )
 

pydynamodb/sql/dml_delete.py

@@ -0,0 +1,74 @@
+# -*- coding: utf-8 -*-
+"""
+Syntax of PartiQL
+https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.delete.html
+------------------
+DELETE FROM table
+WHERE condition [RETURNING returnvalues]
+<returnvalues>  ::= ALL OLD *
+
+Sample SQL of Deleting:
+------------------------
+DELETE FROM "Music" WHERE "Artist" = 'Acme Band' AND "SongTitle" = 'PartiQL Rocks'
+
+DELETE FROM "Music" WHERE "Artist" = 'Acme Band' AND "SongTitle" = 'PartiQL Rocks' RETURNING ALL OLD *
+"""
+import logging
+from .dml_sql import DmlBase
+from .common import KeyWords, Tokens
+from pyparsing import (
+    Forward,
+    Opt,
+)
+from typing import Any, Dict
+
+_logger = logging.getLogger(__name__)  # type: ignore
+
+
+class DmlDelete(DmlBase):
+
+    _DELETE_STATEMENT = (
+        KeyWords.DELETE
+        + KeyWords.FROM
+        + Tokens.TABLE_NAME
+        + KeyWords.WHERE
+        + DmlBase._WHERE_CONDITIONS
+        + Opt(DmlBase._RETURNING_CLAUSE)
+    )("delete_statement").set_name("delete_statement")
+
+    _DML_DELETE_EXPR = Forward()
+    _DML_DELETE_EXPR <<= _DELETE_STATEMENT
+
+    def __init__(self, statement: str) -> None:
+        super().__init__(statement)
+
+    @property
+    def syntax_def(self) -> Forward:
+        return DmlDelete._DML_DELETE_EXPR
+
+    def transform(self) -> Dict[str, Any]:
+        table_name_ = self.root_parse_results["table"]
+
+        table_ = '"%s"' % table_name_
+
+        # Build the statement
+        statement_ = "DELETE FROM {table} {where_conditions}"
+
+        where_conditions = self.root_parse_results.get("where_conditions", None)
+        if where_conditions is not None:
+            where_conditions_ = self._construct_where_conditions(where_conditions)
+        else:
+            where_conditions_ = ""
+
+        statement_ = statement_.format(
+            table=table_, where_conditions=str(where_conditions_)
+        )
+
+        # Add RETURNING clause if present
+        if "returning_clause" in self.root_parse_results:
+            returning = self.root_parse_results["returning_clause"]
+            return_content = returning.get("return_content", "").strip()
+            statement_ += " RETURNING %s" % return_content
+
+        request = {"Statement": statement_.strip()}
+        return request

pydynamodb/sql/dml_insert.py

@@ -0,0 +1,58 @@
+# -*- coding: utf-8 -*-
+"""
+Syntax of PartiQL
+https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.insert.html
+------------------
+INSERT INTO table VALUE item
+
+Sample SQL of Inserting:
+------------------------
+INSERT INTO "Music" value {'Artist' : 'Acme Band','SongTitle' : 'PartiQL Rocks'}
+"""
+import logging
+from .dml_sql import DmlBase
+from .common import KeyWords, Tokens
+from pyparsing import Forward, Group, Regex
+from typing import Any, Dict
+
+_logger = logging.getLogger(__name__)  # type: ignore
+
+
+class DmlInsert(DmlBase):
+
+    # Parse everything inside curly brackets as a single string
+    _ITEM = Group(
+        KeyWords.LCURLYBRACKET
+        + Regex(r"[^}]*")("item_content")
+        + KeyWords.RCURLYBRACKET
+    )("item").set_name("item")
+
+    _INSERT_STATEMENT = (
+        KeyWords.INSERT + KeyWords.INTO + Tokens.TABLE_NAME + KeyWords.VALUE + _ITEM
+    )("insert_statement").set_name("insert_statement")
+
+    _DML_INSERT_EXPR = Forward()
+    _DML_INSERT_EXPR <<= _INSERT_STATEMENT
+
+    def __init__(self, statement: str) -> None:
+        super().__init__(statement)
+
+    @property
+    def syntax_def(self) -> Forward:
+        return DmlInsert._DML_INSERT_EXPR
+
+    def transform(self) -> Dict[str, Any]:
+        table_name_ = self.root_parse_results["table"]
+        item_content_ = self.root_parse_results["item"]["item_content"]
+
+        table_ = '"%s"' % table_name_
+        item_ = "{%s}" % item_content_
+
+        statement_ = "INSERT INTO {table} VALUE {item}"
+        statement_ = statement_.format(
+            table=table_,
+            item=item_,
+        )
+        request = {"Statement": statement_.strip()}
+
+        return request

pydynamodb/sql/dml_select.py

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 """
 Syntax of PartiQL
-https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.select.html#ql-reference.select.syntax
+https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.select.html
 ------------------
 SELECT expression  [, ...]
 FROM table[.index]
@@ -37,8 +37,6 @@
 from collections import OrderedDict
 from .dml_sql import DmlBase, DmlFunction
 from .common import KeyWords, Tokens
-from .util import flatten_list
-from pyparsing import ParseResults
 from pyparsing import Opt, Forward, Group, ZeroOrMore, delimited_list, Regex
 from typing import Any, Dict, List, Optional
 
@@ -147,18 +145,13 @@ class DmlSelect(DmlBase):
 
     def __init__(self, statement: str) -> None:
         super().__init__(statement)
-        self._columns = list()
-        self._where_conditions = list()
+        self._columns = []
         self._is_star_column = False
 
     @property
     def columns(self) -> List[Optional[DmlSelectColumn]]:
         return self._columns
 
-    @property
-    def where_conditions(self) -> List[Optional[str]]:
-        return self._where_conditions
-
     @property
     def is_star_column(self) -> bool:
         return self._is_star_column
@@ -218,7 +211,7 @@ def _construct_columns(self, columns: List[Any]) -> str:
                 self._columns.clear()
                 return "*"
 
-            column_ = list()
+            column_ = []
             column_.append(column["column_name"])
 
             for rcolumn in column["column_ops"]:
@@ -249,43 +242,11 @@ def _construct_columns(self, columns: List[Any]) -> str:
         columns_ = ",".join(columns_.keys())
         return columns_
 
-    def _construct_where_conditions(self, where_conditions: List[Any]) -> str:
-        for condition in where_conditions:
-            if not isinstance(condition, ParseResults):
-                self._where_conditions.append(str(condition))
-            else:
-                function_ = condition.get("function", None)
-                function_with_op_ = condition.get("function_with_op", None)
-                if function_:
-                    flatted_func_params = ",".join(condition["function_params"])
-                    self._where_conditions.append(
-                        "%s(%s)" % (function_, flatted_func_params)
-                    )
-                elif function_with_op_:
-                    flatted_func_params = ",".join(condition["function_params"])
-                    self._where_conditions.append(
-                        "%s(%s) %s %s"
-                        % (
-                            function_with_op_,
-                            flatted_func_params,
-                            condition["comparison_operators"],
-                            condition["column_rvalue"],
-                        )
-                    )
-                else:
-                    where_conditions_ = condition.as_list()
-                    flatted_where = " ".join(
-                        str(c) for c in flatten_list(where_conditions_)
-                    )
-                    self._where_conditions.append(flatted_where)
-
-        return "WHERE %s" % " ".join(self.where_conditions)
-
     def _construct_raw_options(self, options: List[Any]) -> Optional[List[Any]]:
         converted_ = None
         for option in options:
             if converted_ is None:
-                converted_ = list()
+                converted_ = []
 
             converted_.append(" ".join(str(o) for o in option))
 
@@ -295,7 +256,7 @@ def _construct_options(self, options: List[Any]) -> Optional[Dict[str, Any]]:
         converted_ = None
         for option in options:
             if converted_ is None:
-                converted_ = dict()
+                converted_ = {}
             option_name = option[0]
             option_value = option[1]
 

pydynamodb/sql/dml_sql.py

@@ -2,9 +2,11 @@
 import logging
 from abc import ABCMeta
 from .base import Base
-from typing import Any, Dict, List
+from typing import Any, Dict, List, Optional
 from .common import KeyWords, Tokens
+from .util import flatten_list
 from pyparsing import (
+    ParseResults,
     Word,
     CaselessKeyword,
     alphanums,
@@ -19,6 +21,7 @@
     infix_notation,
     pyparsing_common as ppc,
     Combine,
+    Regex,
 )
 
 _logger = logging.getLogger(__name__)  # type: ignore
@@ -121,12 +124,21 @@ class DmlBase(Base):
         )("option").set_name("option")
     )("options").set_name("options")
 
+    _RETURNING_CLAUSE = Group(
+        KeyWords.RETURNING + Regex(r".*")("return_content").set_name("return_content")
+    )("returning_clause").set_name("returning_clause")
+
     def __init__(self, statement: str) -> None:
         super().__init__(statement)
+        self._where_conditions = []
         self._limit = None
         self._consistent_read = False
         self._return_consumed_capacity = "NONE"
 
+    @property
+    def where_conditions(self) -> List[Optional[str]]:
+        return self._where_conditions
+
     @property
     def limit(self) -> int:
         return self._limit
@@ -146,6 +158,38 @@ def syntax_def(self) -> None:
     def transform(self) -> Dict[str, Any]:
         return {"Statement": self._statement}
 
+    def _construct_where_conditions(self, where_conditions: List[Any]) -> str:
+        for condition in where_conditions:
+            if not isinstance(condition, ParseResults):
+                self._where_conditions.append(str(condition))
+            else:
+                function_ = condition.get("function", None)
+                function_with_op_ = condition.get("function_with_op", None)
+                if function_:
+                    flatted_func_params = ",".join(condition["function_params"])
+                    self._where_conditions.append(
+                        "%s(%s)" % (function_, flatted_func_params)
+                    )
+                elif function_with_op_:
+                    flatted_func_params = ",".join(condition["function_params"])
+                    self._where_conditions.append(
+                        "%s(%s) %s %s"
+                        % (
+                            function_with_op_,
+                            flatted_func_params,
+                            condition["comparison_operators"],
+                            condition["column_rvalue"],
+                        )
+                    )
+                else:
+                    where_conditions_ = condition.as_list()
+                    flatted_where = " ".join(
+                        str(c) for c in flatten_list(where_conditions_)
+                    )
+                    self._where_conditions.append(flatted_where)
+
+        return "WHERE %s" % " ".join(self.where_conditions)
+
 
 class DmlFunction(metaclass=ABCMeta):
     def __init__(self, name: str, params: List[str] = None) -> None: