#73 Convert CID to SQL statements

cutplace/fields.py

@@ -379,12 +379,8 @@ def __init__(self, field_name, is_allowed_to_be_empty, length_text, rule, data_f
         self.valid_range = ranges.DecimalRange(rule, ranges.DEFAULT_DECIMAL_RANGE_TEXT)
         self._length = ranges.DecimalRange(length_text)
 
-        if self.valid_range is not None:
-            self._precision = self.valid_range.precision
-            self._scale = self.valid_range.scale
-        else:
-            self._precision = None
-            self._scale = None
+        self._precision = self.valid_range.precision
+        self._scale = self.valid_range.scale
 
     def validated_value(self, value):
         assert value

cutplace/ranges.py

@@ -243,6 +243,7 @@ def __init__(self, description, default=None):
                             raise errors.InterfaceError(
                                 'value for %s must a number, a single character or a symbolic name but is: %s'
                                 % (name_for_code, _compat.text_repr(next_value)), location)
+
                         if ellipsis_found:
                             if upper is None:
                                 upper = value_as_int
@@ -281,7 +282,7 @@ def __init__(self, description, default=None):
                             # Handle "...".
                             raise errors.InterfaceError(
                                 'ellipsis (...) must be preceded and/or succeeded by number', location)
-                        else:
+                        else:  # maybe useless?!
                             # Handle "".
                             result = None
                     else:
@@ -427,7 +428,7 @@ def _item_contains(self, item, value):
             lower = item[0]
             upper = item[1]
             if lower is None:
-                if upper is None:
+                if upper is None:  # ??
                     # Handle ""
                     result = True
                 else:

cutplace/sql.py

@@ -21,6 +21,7 @@
 from __future__ import unicode_literals
 
 import os.path
+import six
 import sqlite3
 
 from cutplace import _tools
@@ -177,7 +178,7 @@ def as_sql_create_table(cid, dialect='ansi'):
     constraints = ""
 
     # get column definitions and constraints for all fields
-    for field in cid._field_formats:
+    for field in cid.field_formats:
         column_def, constraint = field.as_sql(dialect)
         result += column_def + ",\n"
 
@@ -207,3 +208,27 @@ def as_sql_create_table(cid, dialect='ansi'):
             cursor.close()
 
     return result
+
+
+def as_sql_create_inserts(cid, source_data_reader):
+    """
+    :param Cid cid:
+    :param validio.Reader source_data_reader:
+    :return:
+    """
+    assert cid
+    assert source_data_reader
+
+    file_name = os.path.basename(cid._cid_path)
+    table_name = file_name.split('.')[0]
+
+    for row in source_data_reader.rows():
+        for i in range(len(row)):
+
+            # HACK: can't use isinstance() function because of circular dependency when importing fields module
+            fiel_type = six.text_type((cid.field_formats[i]).__class__.__name__)
+            if fiel_type not in ('IntegerFieldFormat', 'DecimalFieldFormat'):
+                row[i] = "'" + row[i] + "'"
+
+        result = "insert into %s(%s) values (%s);" % (table_name, ', '.join(cid.field_names), ', '.join(row))
+        yield result

tests/test_fields.py

@@ -90,6 +90,14 @@ def test_fails_on_invalid_character(self):
                 "character 'x' (code point U+0078, decimal 120) in field 'something' at column 3 must be an allowed"
                 " character: 97...99", six.text_type(anticipated_error))
 
+    def test_can_raise_not_implemented_error(self):
+        field_format = fields.AbstractFieldFormat('x', False, '3...5', '', _ANY_FORMAT)
+        self.assertRaises(NotImplementedError, field_format.validated_value, 4)
+
+    def test_can_output_field_format_as_string(self):
+        field_format = fields.AbstractFieldFormat('x', False, '3...5', '', _ANY_FORMAT)
+        self.assertEqual(six.text_type(field_format), "AbstractFieldFormat('x', False, Range('3...5'), '')")
+
 
 class DateTimeFieldFormatTest(unittest.TestCase):
     """
@@ -475,6 +483,14 @@ def test_fails_on_value_not_matching_pattern(self):
         self.assertRaises(errors.FieldValueError, field_format.validated, "hang")
 
 
+class PublicFieldFunctionTest(unittest.TestCase):
+    """
+    Test for public functions in the fields module
+    """
+    def test_fails_on_non_ascii_character(self):
+        self.assertRaises(errors.InterfaceError, fields.validated_field_name, "a�")
+
+
 if __name__ == '__main__':  # pragma: no cover
     logging.basicConfig()
     logging.getLogger("cutplace").setLevel(logging.INFO)

tests/test_ranges.py

@@ -149,6 +149,9 @@ def test_fails_on_string_with_multiple_characters(self):
     def test_fails_on_unterminated_string(self):
         self.assertRaises(errors.InterfaceError, ranges.Range, "\"\"")
 
+    def test_fails_on_missing_numbers(self):
+        self.assertRaises(errors.InterfaceError, ranges.Range, "...")
+
     def test_can_validate_with_lower_and_upper_limit(self):
         lower_and_upper_range = ranges.Range("-1...1")
         lower_and_upper_range.validate("x", - 1)
@@ -202,12 +205,25 @@ def test_can_create_range_from_length(self):
             ranges.create_range_from_length(
                 ranges.Range("3...4, 10...")).items, [(-999, -10), (100, 9999), (None, -100000000), (1000000000, None)])
 
+    def test_can_display_lower_is_upper_length(self):
+        self.assertEqual(six.text_type(ranges.Range("9...9")), "9")
+
+    def test_can_display_multi_range(self):
+        self.assertEqual(six.text_type(ranges.Range("9...10, 11...13")), "9...10, 11...13")
+
     def test_fails_on_create_range_from_negative_length(self):
         self.assertRaises(errors.RangeValueError, ranges.create_range_from_length, ranges.Range("-19...-1"))
         self.assertRaises(errors.RangeValueError, ranges.create_range_from_length, ranges.Range("-19...1"))
         self.assertRaises(errors.RangeValueError, ranges.create_range_from_length, ranges.Range("-1...0"))
         self.assertRaises(errors.RangeValueError, ranges.create_range_from_length, ranges.Range("0...0"))
 
+    def test_can_represent_range_containing_none(self):
+        none_range = ranges.Range(None)
+        self.assertEqual(six.text_type(none_range), six.text_type(None))
+        upper_none_range = ranges.Range("1...")
+        upper_none_range.items.append(None)
+        self.assertEqual(six.text_type(upper_none_range), "1..., None")
+
 
 class DecimalRangeTest(unittest.TestCase):
 
@@ -408,6 +424,22 @@ def test_can_handle_scientific_notation(self):
             self.assertEqual(7, decimal_range.scale)
             self.assertEqual(2, decimal_range.precision)
 
+    def test_can_display_lower_is_upper_length(self):
+        self.assertEqual(six.text_type(ranges.DecimalRange("9.9...9.9")), "9.9...9.9")
+
+    def test_can_display_multi_range(self):
+        self.assertEqual(six.text_type(ranges.DecimalRange("9.1...10.9, 11...13")), "9.1...10.9, 11.0...13.0")
+
+    def test_can_represent_range_containing_none(self):
+        none_range = ranges.DecimalRange(None)
+        self.assertEqual(six.text_type(none_range), six.text_type(None))
+        upper_none_range = ranges.DecimalRange("1...")
+        upper_none_range.items.append(None)
+        self.assertEqual(six.text_type(upper_none_range), "1, None")
+
+    def test_fails_on_non_decimal_value_to_validate(self):
+        decimal_range = ranges.DecimalRange("1.1...2.2")
+        self.assertRaises(errors.RangeValueError, decimal_range.validate, "x", "a")
 
 if __name__ == "__main__":  # pragma: no cover
     unittest.main()

tests/test_sql.py

@@ -25,6 +25,8 @@
 from cutplace import fields
 from cutplace import interface
 from cutplace import sql
+from cutplace import validio
+from tests import dev_test
 
 import unittest
 
@@ -116,3 +118,14 @@ def test_can_create_sql_statement(self):
             "\nconstraint chk_customer_id check( ( customer_id between 0 and 99999 ) ),"
             "\nconstraint chk_length_surname check (length(surname >= 1) and length(surname <= 60)),"
             "\nconstraint chk_rule_gender check( gender in ('male','female','unknown') )\n);")
+
+        # check if create insert statements works
+        with validio.Reader(cid_reader, dev_test.path_to_test_data("valid_customers.csv")) as reader:
+            self.assertEqual(
+                list(sql.as_sql_create_inserts(cid_reader, reader)),
+                ["insert into customers(branch_id, customer_id, first_name, surname, gender, date_of_birth) "
+                 "values ('38000', 23, 'John', 'Doe', 'male', '08.03.1957');",
+                 "insert into customers(branch_id, customer_id, first_name, surname, gender, date_of_birth) "
+                 "values ('38000', 59, 'Jane', 'Miller', 'female', '04.10.1946');",
+                 "insert into customers(branch_id, customer_id, first_name, surname, gender, date_of_birth) "
+                 "values ('38053', 17, 'Mike', 'Webster', 'male', '23.12.1974');"])