Add more syntax support for SQL query generation

1. Add basic 'HAVING' clause (before the 'ORDER BY' clause).
2. Select source tables in 'DATE_RANGE' format.
3. Add 'BETWEEN' clause in conditions.
4. Modify 'ORDER BY' to accept multiple parameters.

Author: sagarrakshe

bigquery/query_builder.py

@@ -2,7 +2,7 @@
 
 
 def render_query(dataset, tables, select=None, conditions=None,
-                 groupings=None, order_by=None):
+                 groupings=None, having=None, order_by=None):
     """Render a query that will run over the given tables using the specified
     parameters.
 
@@ -46,12 +46,13 @@ def render_query(dataset, tables, select=None, conditions=None,
     if None in (dataset, tables):
         return None
 
-    query = "%s %s %s %s %s" % (
+    query = "%s %s %s %s %s %s" % (
         _render_select(select),
         _render_sources(dataset, tables),
         _render_conditions(conditions),
         _render_groupings(groupings),
-        _render_order(order_by),
+        _render_having(having),
+        _render_order(order_by)
     )
 
     return query
@@ -85,7 +86,7 @@ def _render_select(selections):
         for options_dict in options:
             name = original_name
             alias = options_dict.get('alias')
-            alias = "as %s" % alias if alias else ""
+            alias = "AS %s" % alias if alias else ""
 
             formatter = options_dict.get('format')
             if formatter:
@@ -133,8 +134,20 @@ def _render_sources(dataset, tables):
         a string that represents the from part of a query.
     """
 
-    return "FROM " + ", ".join(
-        ["[%s.%s]" % (dataset, table) for table in tables])
+    if isinstance(tables, dict):
+        if tables['date_range']:
+            try:
+                dataset_table = '.'.join([dataset, tables['table']])
+                return "FROM (TABLE_DATE_RANGE([{}], TIMESTAMP('{}'),"\
+                    " TIMESTAMP('{}'))) ".format(dataset_table,
+                                                 tables['from_date'],
+                                                 tables['to_date'])
+            except KeyError as exp:
+                raise Exception('Missing parameter %s' % (exp))
+
+    else:
+        return "FROM " + ", ".join(
+            ["[%s.%s]" % (dataset, table) for table in tables])
 
 
 def _render_conditions(conditions):
@@ -206,6 +219,12 @@ def _render_condition(field, field_type, comparators):
             else:
                 value = _render_condition_value(value, field_type)
             value = "(" + value + ")"
+        elif condition == "BETWEEN":
+            if isinstance(value, (tuple, list)):
+                value = ' AND '.join(
+                    sorted([_render_condition_value(v, field_type)
+                            for v in value])
+                )
         else:
             value = _render_condition_value(value, field_type)
 
@@ -242,25 +261,40 @@ def _render_condition_value(value, field_type):
         value = 1 if value else 0
     elif field_type in ("STRING", "INTEGER", "FLOAT"):
         value = "'%s'" % (value)
+    elif field_type in ("TIMESTAMP"):
+        value = "'%s'" % (str(value))
     return "%s(%s)" % (field_type, value)
 
 
+def _render_having(having):
+    """Render the having part of a query.
+
+    Args:
+        having: accepts the having query as it is.
+
+    Returns:
+        a string that represents the having part of a query.
+    """
+
+    return "HAVING %s" % (having) if having else ""
+
+
 def _render_order(order):
     """Render the order by part of a query.
 
     Args:
         order: a dictionary with two keys, field and direction.
             Such that the dictionary should be formatted as
-            {'field':'TimeStamp, 'direction':'desc'}.
+            {'fields': ['TimeStamp'], 'direction':'desc'}.
 
     Returns:
         a string that represents the order by part of a query.
     """
 
-    if not order or 'field' not in order or 'direction' not in order:
+    if not order or 'fields' not in order or 'direction' not in order:
         return ''
 
-    return "ORDER BY %s %s" % (order['field'], order['direction'])
+    return "ORDER BY %s %s" % (", ".join(order['fields']), order['direction'])
 
 
 def _render_groupings(fields):