dist_gen.constant generates NULL, 0 or "" as appropriate (#52)

Co-authored-by: Tim Band <t.b@ucl>

Author: tim-band

datafaker/generators.py

@@ -828,17 +828,19 @@ def get_generators(self, column: Column, engine: Engine):
         return generators
 
 
-class NullGenerator(Generator):
-    def __init__(self):
+class ConstantGenerator(Generator):
+    def __init__(self, value):
         super().__init__()
+        self.value = value
+        self.repr = repr(value)
     def function_name(self) -> str:
         return "dist_gen.constant"
     def nominal_kwargs(self) -> dict[str, str]:
-        return {"value": "None"}
+        return {"value": self.repr}
     def actual_kwargs(self) -> dict[str, any]:
-        return {"value": None}
+        return {"value": self.value}
     def generate_data(self, count) -> list[any]:
-        return [None for _ in range(count)]
+        return [self.value for _ in range(count)]
 
 
 class ConstantGeneratorFactory(GeneratorFactory):
@@ -847,7 +849,14 @@ class ConstantGeneratorFactory(GeneratorFactory):
     """
     def get_generators(self, column: Column, _engine: Engine):
         if column.nullable:
-            return [NullGenerator()]
+            return [ConstantGenerator(None)]
+        c_type = get_column_type(column)
+        if isinstance(c_type, String):
+            return [ConstantGenerator("")]
+        if isinstance(c_type, Numeric):
+            return [ConstantGenerator(0.0)]
+        if isinstance(c_type, Integer):
+            return [ConstantGenerator(0)]
         return []
 
 

tests/test_interactive.py

@@ -831,3 +831,55 @@ def test_create_with_missingness(self):
                 patterns.add(p + b)
             # all pattern possibilities should be present
             self.assertSetEqual(patterns, {0, 1, 2, 3})
+
+
+class GeneratorTests(GeneratesDBTestCase):
+    """ Testing configure-missing with generation. """
+    dump_file_path = "instrument.sql"
+    database_name = "instrument"
+    schema_name = "public"
+
+    def _get_cmd(self, config) -> TestGeneratorCmd:
+        return TestGeneratorCmd(self.dsn, self.schema_name, self.metadata, config)
+
+    def test_set_null(self):
+        """ Test that we can sample real missingness and reproduce it. """
+        with self._get_cmd({}) as gc:
+            gc.do_next("string.position")
+            gc.do_set("dist_gen.constant")
+            self.assertListEqual(gc.messages, [])
+            gc.reset()
+            gc.do_next("string.frequency")
+            gc.do_set("dist_gen.constant")
+            self.assertListEqual(gc.messages, [])
+            gc.reset()
+            gc.do_next("signature_model.name")
+            gc.do_set("dist_gen.constant")
+            self.assertListEqual(gc.messages, [])
+            gc.reset()
+            gc.do_next("signature_model.based_on")
+            gc.do_set("dist_gen.constant")
+            # we have got to the end of the columns, but shouldn't have any errors
+            self.assertListEqual(gc.messages, [("No more tables", (), {})])
+            gc.reset()
+            gc.do_quit("")
+            config = gc.config
+            self.generate_data(config, num_passes=3)
+        # Test that each missingness pattern is present in the database
+        with self.engine.connect() as conn:
+            stmt = select(self.metadata.tables["string"].c["position", "frequency"])
+            rows = conn.execute(stmt).fetchall()
+            count = 0
+            for row in rows:
+                count += 1
+                self.assertEqual(row.position, 0)
+                self.assertEqual(row.frequency, 0.0)
+            self.assertEqual(count, 3)
+            stmt = select(self.metadata.tables["signature_model"].c["name", "based_on"])
+            rows = conn.execute(stmt).fetchall()
+            count = 0
+            for row in rows:
+                count += 1
+                self.assertEqual(row.name, "")
+                self.assertIsNone(row.based_on)
+            self.assertEqual(count, 3)