Merge pull request #37 from nordic-institute/develop

Changes to release 1.1.1
nordic-institute · Mar 10, 2023 · bdd1074 · bdd1074
2 parents 4e77c9b + f8d5736
commit bdd1074
Show file tree

Hide file tree

Showing 2 changed files with 36 additions and 41 deletions.
diff --git a/anonymizer_module/opmon_anonymizer/iio/postgresql_manager.py b/anonymizer_module/opmon_anonymizer/iio/postgresql_manager.py
@@ -109,7 +109,7 @@ def _table_exists(self, cursor):
                 WHERE  table_schema = 'public'
                 AND table_name = %s
             );
-        """, (cursor._table_name,))
+        """, (self._table_name,))
 
         return cursor.fetchone()[0]
 
@@ -131,10 +131,17 @@ def _ensure_privileges(self):
                 for readonly_user in self._readonly_users:
                     try:
                         cursor.execute(
-                            "GRANT USAGE ON SCHEMA public TO %s;", (readonly_user,)
+                            "GRANT USAGE ON SCHEMA public TO {readony_user};".format(
+                                **{
+                                    'readonly_user': readonly_user
+                                })
                         )
                         cursor.execute(
-                            "GRANT SELECT ON %s TO %s;", (self._table_name, readonly_user)
+                            "GRANT SELECT ON {table_name} TO {readonly_user};".format(
+                                **{
+                                    'table_name': self._table_name,
+                                    'readonly_user': readonly_user
+                                })
                         )
                     except Exception:
                         pass  # Privileges existed

diff --git a/opendata_module/opmon_opendata/api/postgresql_manager.py b/opendata_module/opmon_opendata/api/postgresql_manager.py
@@ -42,9 +42,8 @@ def __init__(self, settings):
     def get_column_names_and_types(self):
         with pg.connect(self._connection_string, **self._connect_args) as connection:
             cursor = connection.cursor()
-            cursor.execute(
-                "SELECT column_name,data_type FROM information_schema.columns WHERE table_name = %s;",
-                (self._table_name,))
+            cursor.execute("SELECT column_name,data_type FROM information_schema.columns WHERE table_name = %s;",
+                           (self._table_name,))
             data = cursor.fetchall()
 
         return [(self._field_name_map[name], type_) for name, type_ in data]
@@ -63,22 +62,21 @@ def get_data_cursor(
             order_by_str = self._get_order_by_string(order_by, subquery_name)
             limit_str = self._get_limit_string(cursor, limit)
 
-            query = """SELECT %(selected_columns)s
-            FROM (
-                SELECT * FROM %s(table_name)s %(request_in_data_constraint)s
+            cursor.execute(
+                ("SELECT {selected_columns} FROM (SELECT * "
+                 "FROM {table_name} {request_in_date_constraint}) as {subquery_name} {other_constraints}"
+                 "{order_by} {limit};").format(
+                    **{
+                        'selected_columns': selected_columns_str,
+                        'table_name': self._table_name,
+                        'request_in_date_constraint': request_in_date_constraint_str,
+                        'other_constraints': other_constraints_str,
+                        'order_by': order_by_str,
+                        'limit': limit_str,
+                        'subquery_name': subquery_name}
                 )
-                as %(subquery_name)s %(other_constraints)s %(order_by)s %(limit)s;
-                """
-            params = {
-                'selected_columns': selected_columns_str,
-                'table_name': self._table_name,
-                'request_in_data_constraint': request_in_date_constraint_str,
-                'subquery_name': subquery_name,
-                'other_constraints': other_constraints_str,
-                'order_by': order_by_str,
-                'limit': limit_str,
-            }
-            cursor.execute(query, params)
+            )
+
             return cursor
 
     def get_data(self, constraints=None, order_by=None, columns=None, limit=None):
@@ -87,9 +85,7 @@ def get_data(self, constraints=None, order_by=None, columns=None, limit=None):
     def get_min_and_max_dates(self):
         with pg.connect(self._connection_string, **self._connect_args) as connection:
             cursor = connection.cursor()
-            cursor.execute(
-                "SELECT min(requestindate), max(requestindate) FROM %s;", (self._table_name,)
-            )
+            cursor.execute('SELECT min(requestindate), max(requestindate) FROM ' + self._table_name)
             min_and_max = [date - self._logs_time_buffer for date in cursor.fetchone()]
 
         return min_and_max
@@ -134,24 +130,16 @@ def _get_constraints_string(self, cursor, constraints, subquery_name):
                         'subquery_name': subquery_name
                     }))
                 else:
-                    other_constraint_parts.append(cursor.mogrify(
-                        "%s.%s %s %s",
-                        (
-                            subquery_name,
-                            constraint['column'].lower(),
-                            constraint['operator'],
-                            constraint['value'],
-                        )
-                    ).decode('utf8'))
+                    other_constraint_parts.append(cursor.mogrify("{subquery_name}.{column} {operator} %s".format(**{
+                        'column': constraint['column'].lower(),
+                        'operator': constraint['operator'],
+                        'subquery_name': subquery_name
+                    }), (constraint['value'],)).decode('utf8'))
             else:
-                request_in_date_constraint = 'WHERE ' + cursor.mogrify(
-                    "%s %s %s",
-                    (
-                        constraint['column'].lower(),
-                        constraint['operator'],
-                        constraint['value'],
-                    )
-                ).decode('utf8')
+                request_in_date_constraint = 'WHERE ' + cursor.mogrify("{column} {operator} %s".format(**{
+                    'column': constraint['column'].lower(),
+                    'operator': constraint['operator']
+                }), (constraint['value'],)).decode('utf8')
 
         other_constraints = ('WHERE ' + ' AND '.join(other_constraint_parts)) if other_constraint_parts else ''