adding basic foundations for JSON field

Author: dantownsend

piccolo/columns/base.py

@@ -325,7 +325,7 @@ def get_select_string(self, engine_type: str, just_alias=False) -> str:
         """
         return self._meta.get_full_name(just_alias=just_alias)
 
-    def get_sql_value(self, value: t.Any) -> str:
+    def get_sql_value(self, value: t.Any) -> t.Any:
         """
         When using DDL statements, we can't parameterise the values. An example
         is when setting the default for a column. So we have to convert from
@@ -390,6 +390,13 @@ def querystring(self) -> QueryString:
         if not self._meta.primary:
             default = self.get_default_value()
             sql_value = self.get_sql_value(value=default)
+            # Escape the value if it contains a pair of curly braces, otherwise
+            # an empty value will appear in the compiled querystring.
+            sql_value = (
+                sql_value.replace("{}", "{{}}")
+                if isinstance(sql_value, str)
+                else sql_value
+            )
             query += f" DEFAULT {sql_value}"
 
         return QueryString(query)

piccolo/columns/column_types.py

@@ -1039,3 +1039,34 @@ def __getattribute__(self, name: str):
             return new_column
         else:
             return value
+
+
+###############################################################################
+
+
+class JSON(Column):
+    """
+    Used for storing JSON strings. In Postgres, the JSON can be queried
+    directly. The data is stored as a string. This is preferable to JSONB
+    if you just want to store and retrieve JSON without querying it directly.
+
+    """
+
+    value_type = str
+
+    def __init__(self, default: t.Union[str, None] = "{}", **kwargs) -> None:
+        self._validate_default(default, (str, None))
+        self.default = default
+        kwargs.update({"default": default})
+        super().__init__(**kwargs)
+
+
+class JSONB(Column):
+    """
+    Used for storing JSON strings. In Postgres, the JSON can be queried
+    directly. The data is stored in a binary format, which makes querying
+    faster, but insertion and retrieval slower (as it needs to be converted
+    to and from the binary format).
+    """
+
+    pass

tests/columns/test_json.py

@@ -0,0 +1,30 @@
+from unittest import TestCase
+
+from piccolo.table import Table
+from piccolo.columns.column_types import JSON
+
+
+class MyTable(Table):
+    json = JSON()
+
+
+class MyTableDefault(Table):
+    json = JSON(default="{}")
+
+
+class TestJSON(TestCase):
+    def setUp(self):
+        MyTable.create_table().run_sync()
+
+    def tearDown(self):
+        MyTable.alter().drop_table().run_sync()
+
+    def test_json(self):
+        row = MyTable(json='{"a": 1}')
+        row.save().run_sync()
+        self.assertEqual(row.json, '{"a": 1}')
+
+    def test_json_default(self):
+        row = MyTable()
+        row.save().run_sync()
+        self.assertEqual(row.json, "{}")

tests/query/test_querystring.py

@@ -13,7 +13,9 @@ class TestQueryString(TestCase):
     def test_compile_string(self):
         compiled_string, args = self.qs.compile_string()
 
-        self.assertEqual(compiled_string, "SELECT id FROM band WHERE name = $1")
+        self.assertEqual(
+            compiled_string, "SELECT id FROM band WHERE name = $1"
+        )
 
         self.assertEqual(args, ["Pythonistas"])
 

tests/table/test_insert.py

@@ -29,3 +29,16 @@ def test_incompatible_type(self):
         """
         with self.assertRaises(TypeError):
             Band.insert().add(Manager(name="Guido")).run_sync()
+
+    def test_insert_curly_braces(self):
+        """
+        You should be able to insert curly braces without an error.
+        """
+        self.insert_rows()
+
+        Band.insert(Band(name="{}", popularity=100)).run_sync()
+
+        response = Band.select(Band.name).run_sync()
+        names = [i["name"] for i in response]
+
+        self.assertTrue("{}" in names)