Skip to content

Commit b7ef0a1

Browse files
a-detistea-detiste
authored
all the strings are Unicode in Python3 (#562)
1 parent a9800cc commit b7ef0a1

7 files changed

Lines changed: 82 additions & 82 deletions

File tree

‎vertica_python/tests/integration_tests/test_column.py‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -40,11 +40,11 @@
4040

4141
class ColumnTestCase(VerticaPythonIntegrationTestCase):
4242
def test_column_names_query(self):
43-
columns = ['isocode', 'name', u'\uFF04']
43+
columns = ['isocode', 'name', '\uFF04']
4444

4545
with self._connect() as conn:
4646
cur = conn.cursor()
47-
cur.execute(u"""
47+
cur.execute("""
4848
SELECT 'US' AS {0}, 'United States' AS {1}, 'USD' AS {2}
4949
UNION ALL SELECT 'CA', 'Canada', 'CAD'
5050
UNION ALL SELECT 'MX', 'Mexico', 'MXN' """.format(*columns))

‎vertica_python/tests/integration_tests/test_cursor.py‎

Lines changed: 25 additions & 25 deletions
Original file line numberDiff line numberDiff line change
@@ -776,16 +776,16 @@ def test_qmark_paramstyle(self):
776776
def test_execute_parameters(self):
777777
with self._connect() as conn:
778778
cur = conn.cursor()
779-
all_chars = u"".join(chr(i) for i in range(1, 128))
780-
backslash_data = u"\\backslash\\ \\data\\\\"
779+
all_chars = "".join(chr(i) for i in range(1, 128))
780+
backslash_data = "\\backslash\\ \\data\\\\"
781781
cur.execute("SELECT :a, :b", parameters={"a": all_chars, "b": backslash_data})
782782
self.assertEqual([all_chars, backslash_data], cur.fetchone())
783783

784784
def test_execute_percent_parameters(self):
785785
with self._connect() as conn:
786786
cur = conn.cursor()
787-
all_chars = u"".join(chr(i) for i in range(1, 128))
788-
backslash_data = u"\\backslash\\ \\data\\\\"
787+
all_chars = "".join(chr(i) for i in range(1, 128))
788+
backslash_data = "\\backslash\\ \\data\\\\"
789789
cur.execute("SELECT %s, %s", parameters=[all_chars, backslash_data])
790790
self.assertEqual([all_chars, backslash_data], cur.fetchone())
791791

@@ -898,16 +898,16 @@ def test_copy_local_stdin_multistat(self):
898898

899899
# Check rejected files
900900
with open(rej1, 'r', encoding='utf-8') as f:
901-
self.assertEqual(f.read(), u'x\u00f1,bla\n')
901+
self.assertEqual(f.read(), 'x\u00f1,bla\n')
902902
with open(except1, 'r', encoding='utf-8') as f:
903903
content = f.read()
904-
self.assertTrue(u"Invalid integer format 'x\u00f1' for column 1 (a)" in content)
904+
self.assertTrue("Invalid integer format 'x\u00f1' for column 1 (a)" in content)
905905
with open(rej2, 'r', encoding='utf-8') as f:
906-
self.assertEqual(f.read(), u'10,kkkkkkkkkkkk\nxx,corge\n')
906+
self.assertEqual(f.read(), '10,kkkkkkkkkkkk\nxx,corge\n')
907907
with open(except2, 'r', encoding='utf-8') as f:
908908
content = f.read()
909-
self.assertTrue(u"The 12-byte value is too long for type Varchar(9), column 2 (b)" in content)
910-
self.assertTrue(u"Invalid integer format 'xx' for column 1 (a)" in content)
909+
self.assertTrue("The 12-byte value is too long for type Varchar(9), column 2 (b)" in content)
910+
self.assertTrue("Invalid integer format 'xx' for column 1 (a)" in content)
911911

912912
# Delete data files
913913
try:
@@ -1004,18 +1004,18 @@ def test_copy_local_file_multistat(self, fetch_results):
10041004

10051005
# Check rejected files
10061006
with open(rej1, 'r', encoding='utf-8') as f:
1007-
self.assertEqual(f.read(), u'x\u00f1,bla\n5,aaaaaaaaaa\n')
1007+
self.assertEqual(f.read(), 'x\u00f1,bla\n5,aaaaaaaaaa\n')
10081008
with open(except1, 'r', encoding='utf-8') as f:
10091009
content = f.read()
1010-
self.assertTrue(u"Invalid integer format 'x\u00f1' for column 1 (a)" in content)
1011-
self.assertTrue(u"The 10-byte value is too long for type Varchar(9), column 2 (b)" in content)
1010+
self.assertTrue("Invalid integer format 'x\u00f1' for column 1 (a)" in content)
1011+
self.assertTrue("The 10-byte value is too long for type Varchar(9), column 2 (b)" in content)
10121012
with open(rej2, 'r', encoding='utf-8') as f:
1013-
self.assertEqual(f.read(), u'10,kkkkkkkkkkkk\nxx,corge\nf,quux\n')
1013+
self.assertEqual(f.read(), '10,kkkkkkkkkkkk\nxx,corge\nf,quux\n')
10141014
with open(except2, 'r', encoding='utf-8') as f:
10151015
content = f.read()
1016-
self.assertTrue(u"The 12-byte value is too long for type Varchar(9), column 2 (b)" in content)
1017-
self.assertTrue(u"Invalid integer format 'xx' for column 1 (a)" in content)
1018-
self.assertTrue(u"Invalid integer format 'f' for column 1 (a)" in content)
1016+
self.assertTrue("The 12-byte value is too long for type Varchar(9), column 2 (b)" in content)
1017+
self.assertTrue("Invalid integer format 'xx' for column 1 (a)" in content)
1018+
self.assertTrue("Invalid integer format 'f' for column 1 (a)" in content)
10191019

10201020
# Delete files
10211021
try:
@@ -1059,7 +1059,7 @@ def test_copy_local_rejected_as_table(self):
10591059
cur.execute("SELECT rejected_data, rejected_reason FROM test_loader_rejects ORDER BY row_number ASC")
10601060
self.assertListOfListsEqual(cur.fetchall(),
10611061
[['5,aaaaaaaaaa', 'The 10-byte value is too long for type Varchar(9), column 2 (b)'],
1062-
[u'x\u00f1,bla', u"Invalid integer format 'x\u00f1' for column 1 (a)"]])
1062+
['x\u00f1,bla', "Invalid integer format 'x\u00f1' for column 1 (a)"]])
10631063

10641064
cur.execute("SELECT * FROM {0} ORDER BY a ASC".format(self._table))
10651065
self.assertListOfListsEqual(cur.fetchall(), [[None, 'baz'], [1, 'foo'], [2, 'bar'], [4, None]])
@@ -1141,7 +1141,7 @@ def test_executemany_quoted_path(self):
11411141
self._test_executemany(table, [(1, 'aa'), (2, 'bb')])
11421142

11431143
def test_executemany_utf8(self):
1144-
self._test_executemany(self._table, [(1, u'a\xfc'), (2, u'bb')])
1144+
self._test_executemany(self._table, [(1, 'a\xfc'), (2, 'bb')])
11451145

11461146
# test for #292
11471147
def test_executemany_autocommit(self):
@@ -1283,8 +1283,8 @@ def test_named_paramstyle(self):
12831283
self.assertListOfListsEqual(res, [[1, 'varchar']])
12841284

12851285
def test_executemany(self):
1286-
values = ((None, 'foo'), [1, 'aa'], (2, None), [2, u'a\xfc'])
1287-
expected = [[None, 'foo'], [1, 'aa'], [2, None], [2, u'a\xfc']]
1286+
values = ((None, 'foo'), [1, 'aa'], (2, None), [2, 'a\xfc'])
1287+
expected = [[None, 'foo'], [1, 'aa'], [2, None], [2, 'a\xfc']]
12881288
with self._connect() as conn:
12891289
cur = conn.cursor()
12901290
cur.execute("CREATE TABLE {} (a int, b varchar)".format(self._table))
@@ -1312,7 +1312,7 @@ def test_executemany(self):
13121312
self.assertIsNone(cur.fetchone())
13131313
self.assertTrue(cur.nextset())
13141314

1315-
self.assertListOfListsEqual(cur.fetchall(), [[2, u'a\xfc'], [2, None]])
1315+
self.assertListOfListsEqual(cur.fetchall(), [[2, 'a\xfc'], [2, None]])
13161316
self.assertIsNone(cur.fetchone())
13171317
self.assertTrue(cur.nextset())
13181318

@@ -1353,8 +1353,8 @@ def test_bind_datetime(self):
13531353
self.assertListOfListsEqual(res, [values])
13541354

13551355
def test_bind_binary(self):
1356-
values = [b'binary data', b'\\backslash data\\', u'\\backslash data\\',
1357-
u'\u00f1 encoding', 'raw data', 'long varbinary data', None]
1356+
values = [b'binary data', b'\\backslash data\\', '\\backslash data\\',
1357+
'\u00f1 encoding', 'raw data', 'long varbinary data', None]
13581358
expected = [[b'binary data\x00\x00\x00', b'\\backslash data\\',
13591359
b'\\backslash data\\', b'\xc3\xb1 encoding',
13601360
b'raw data', b'long varbinary data', None]]
@@ -1398,9 +1398,9 @@ def test_bind_numeric(self):
13981398

13991399
def test_bind_character(self):
14001400
values = ['char data', b'raw varchar data',
1401-
u'long varbinary data \u00f1', None, None, None]
1401+
'long varbinary data \u00f1', None, None, None]
14021402
expected = [['char data ', 'raw varchar data',
1403-
u'long varbinary data \u00f1', None, None, None]]
1403+
'long varbinary data \u00f1', None, None, None]]
14041404
with self._connect() as conn:
14051405
cur = conn.cursor()
14061406
cur.execute("""CREATE TABLE {} (

‎vertica_python/tests/integration_tests/test_datatypes.py‎

Lines changed: 13 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -136,10 +136,10 @@ def test_Array_numeric_type(self):
136136
None, [], [None]], test_executemany=True)
137137

138138
def test_Array_char_type(self):
139-
self._test_insert_complex_type('ARRAY[CHAR(3)]', [['a', u'\u16b1', None, 'foo'], None, [], [None]], [['a ', u'\u16b1', None, 'foo'], None, [], [None]], test_executemany=True)
139+
self._test_insert_complex_type('ARRAY[CHAR(3)]', [['a', '\u16b1', None, 'foo'], None, [], [None]], [['a ', '\u16b1', None, 'foo'], None, [], [None]], test_executemany=True)
140140

141141
def test_Array_varchar_type(self):
142-
self._test_insert_complex_type('ARRAY[VARCHAR(10)]', [['', u'\u16b1\nb', None, 'foo'], None, [], [None]], test_executemany=True)
142+
self._test_insert_complex_type('ARRAY[VARCHAR(10)]', [['', '\u16b1\nb', None, 'foo'], None, [], [None]], test_executemany=True)
143143
self._test_insert_complex_type('ARRAY[VARCHAR]', [[chr(i)] for i in range(1, 128)], test_executemany=True)
144144

145145
def test_Array_date_type(self):
@@ -178,10 +178,10 @@ def test_1DSet_numeric_type(self):
178178
None, set(), {None}], test_executemany=True)
179179

180180
def test_1DSet_char_type(self):
181-
self._test_insert_complex_type('SET[CHAR(3)]', [{'a ', u'\u16b1', None, 'foo'}, None, set(), {None}], test_executemany=True)
181+
self._test_insert_complex_type('SET[CHAR(3)]', [{'a ', '\u16b1', None, 'foo'}, None, set(), {None}], test_executemany=True)
182182

183183
def test_1DSet_varchar_type(self):
184-
self._test_insert_complex_type('SET[VARCHAR(10)]', [{'', u'\u16b1\nb', None, 'foo'}, None, set(), {None}], test_executemany=True)
184+
self._test_insert_complex_type('SET[VARCHAR(10)]', [{'', '\u16b1\nb', None, 'foo'}, None, set(), {None}], test_executemany=True)
185185
self._test_insert_complex_type('SET[VARCHAR]', [{chr(i)} for i in range(1, 128)], test_executemany=True)
186186

187187
def test_1DSet_date_type(self):
@@ -339,16 +339,16 @@ def test_1DArray_numeric_type(self):
339339
self.assertEqual(res[2], None)
340340

341341
def test_1DArray_char_type(self):
342-
query = u"SELECT ARRAY['a', '\u16b1b', null, 'foo']::ARRAY[CHAR(3)], ARRAY[]::ARRAY[CHAR(4)], null::ARRAY[CHAR(5)]"
342+
query = "SELECT ARRAY['a', '\u16b1b', null, 'foo']::ARRAY[CHAR(3)], ARRAY[]::ARRAY[CHAR(4)], null::ARRAY[CHAR(5)]"
343343
res = self._query_and_fetchone(query)
344-
self.assertEqual(res[0], ['a ', u'\u16b1', None, 'foo'])
344+
self.assertEqual(res[0], ['a ', '\u16b1', None, 'foo'])
345345
self.assertEqual(res[1], [])
346346
self.assertEqual(res[2], None)
347347

348348
def test_1DArray_varchar_type(self):
349-
query = u"SELECT ARRAY['', '\u16b1\nb', null, 'foo']::ARRAY[VARCHAR(10),4], ARRAY[]::ARRAY[VARCHAR(4)], null::ARRAY[VARCHAR]"
349+
query = "SELECT ARRAY['', '\u16b1\nb', null, 'foo']::ARRAY[VARCHAR(10),4], ARRAY[]::ARRAY[VARCHAR(4)], null::ARRAY[VARCHAR]"
350350
res = self._query_and_fetchone(query)
351-
self.assertEqual(res[0], ['', u'\u16b1\nb', None, 'foo'])
351+
self.assertEqual(res[0], ['', '\u16b1\nb', None, 'foo'])
352352
self.assertEqual(res[1], [])
353353
self.assertEqual(res[2], None)
354354

@@ -564,16 +564,16 @@ def test_1DSet_numeric_type(self):
564564
self.assertEqual(res[2], None)
565565

566566
def test_1DSet_char_type(self):
567-
query = u"SELECT SET['a', '\u16b1b', null, 'foo']::SET[CHAR(3)], SET[]::SET[CHAR(4)], null::SET[CHAR(5)]"
567+
query = "SELECT SET['a', '\u16b1b', null, 'foo']::SET[CHAR(3)], SET[]::SET[CHAR(4)], null::SET[CHAR(5)]"
568568
res = self._query_and_fetchone(query)
569-
self.assertEqual(res[0], {'a ', u'\u16b1', None, 'foo'})
569+
self.assertEqual(res[0], {'a ', '\u16b1', None, 'foo'})
570570
self.assertEqual(res[1], set())
571571
self.assertEqual(res[2], None)
572572

573573
def test_1DSet_varchar_type(self):
574-
query = u"SELECT SET['', '\u16b1\nb', null, 'foo']::SET[VARCHAR(10),4], SET[]::SET[VARCHAR(4)], null::SET[VARCHAR]"
574+
query = "SELECT SET['', '\u16b1\nb', null, 'foo']::SET[VARCHAR(10),4], SET[]::SET[VARCHAR(4)], null::SET[VARCHAR]"
575575
res = self._query_and_fetchone(query)
576-
self.assertEqual(res[0], {'', u'\u16b1\nb', None, 'foo'})
576+
self.assertEqual(res[0], {'', '\u16b1\nb', None, 'foo'})
577577
self.assertEqual(res[1], set())
578578
self.assertEqual(res[2], None)
579579

@@ -594,7 +594,7 @@ def test_1DSet_time_type(self):
594594
def test_1DSet_timetz_type(self):
595595
query = "SELECT SET['22:36:33.12345+0630', null, '800-02-03 22:36:33.123456 America/Cayman']::SET[TIMETZ(3)], SET[]::SET[TIMETZ(4)], null::SET[TIMETZ]"
596596
res = self._query_and_fetchone(query)
597-
self.assertEqual(res[0], {time(22, 36, 33, 123000, tzinfo=tzoffset(None, 23400)), None,
597+
self.assertEqual(res[0], {time(22, 36, 33, 123000, tzinfo=tzoffset(None, 23400)), None,
598598
time(22, 36, 33, 123000, tzinfo=tzoffset(None, -19176))})
599599
self.assertEqual(res[1], set())
600600
self.assertEqual(res[2], None)

‎vertica_python/tests/integration_tests/test_transfer_format.py‎

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -37,7 +37,7 @@ def tearDownClass(cls):
3737

3838
def _test_equal_value(self, sql_type, data_list, assert_almost_equal=False):
3939
for data in data_list:
40-
query = u"SELECT {}{}".format(data, "::" + sql_type if sql_type else '')
40+
query = "SELECT {}{}".format(data, "::" + sql_type if sql_type else '')
4141
self.text_cursor.execute(query)
4242
self.binary_cursor.execute(query)
4343
text_val = self.text_cursor.fetchone()[0]
@@ -67,9 +67,9 @@ def test_numeric_type(self):
6767
self._test_equal_value("DECIMAL", ["123456789.98765"])
6868

6969
def test_char_type(self):
70-
self._test_equal_value("CHAR(8)", [u"'\u16b1'"])
71-
self._test_equal_value("VARCHAR", [u"'foo\u16b1'"])
72-
self._test_equal_value("LONG VARCHAR", [u"'foo \u16b1 bar'"])
70+
self._test_equal_value("CHAR(8)", ["'\u16b1'"])
71+
self._test_equal_value("VARCHAR", ["'foo\u16b1'"])
72+
self._test_equal_value("LONG VARCHAR", ["'foo \u16b1 bar'"])
7373

7474
def test_datetime_type(self):
7575
self._test_equal_value("DATE", ["'0340-01-20'", "'2001-12-01'", "'9999-12-31'"])
@@ -98,9 +98,9 @@ def test_UUID_type(self):
9898
self._test_equal_value("UUID", ["'00010203-0405-0607-0809-0a0b0c0d0e0f'", "'123e4567-e89b-12d3-a456-426655440a00'"])
9999

100100
def test_binary_type(self):
101-
self._test_equal_value("BINARY(2)", [u"'\303\261'"])
102-
self._test_equal_value("VARBINARY", [u"'\303\261'"])
103-
self._test_equal_value("LONG VARBINARY", [u"'\303\261\303\260'"])
101+
self._test_equal_value("BINARY(2)", ["'\303\261'"])
102+
self._test_equal_value("VARBINARY", ["'\303\261'"])
103+
self._test_equal_value("LONG VARBINARY", ["'\303\261\303\260'"])
104104

105105
def test_array_type(self):
106106
self._test_equal_value("ARRAY[INT]", ["ARRAY[1,2,3]"])

‎vertica_python/tests/integration_tests/test_unicode.py‎

Lines changed: 16 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -40,8 +40,8 @@
4040

4141
class UnicodeTestCase(VerticaPythonIntegrationTestCase):
4242
def test_unicode_query(self):
43-
value = u'\u16a0'
44-
query = u"SELECT '{0}'".format(value)
43+
value = '\u16a0'
44+
query = "SELECT '{0}'".format(value)
4545

4646
with self._connect() as conn:
4747
cur = conn.cursor()
@@ -51,8 +51,8 @@ def test_unicode_query(self):
5151
self.assertResultEqual(value, res[0])
5252

5353
def test_unicode_list_parameter(self):
54-
values = [u'\u00f1', 'foo', 3]
55-
query = u"SELECT {0}".format(", ".join(["%s"] * len(values)))
54+
values = ['\u00f1', 'foo', 3]
55+
query = "SELECT {0}".format(", ".join(["%s"] * len(values)))
5656

5757
with self._connect() as conn:
5858
cur = conn.cursor()
@@ -63,10 +63,10 @@ def test_unicode_list_parameter(self):
6363
self.assertResultEqual(val, res)
6464

6565
def test_unicode_named_parameter_binding(self):
66-
values = [u'\u16b1', 'foo', 3]
67-
keys = [u'\u16a0', 'foo', 3]
66+
values = ['\u16b1', 'foo', 3]
67+
keys = ['\u16a0', 'foo', 3]
6868

69-
query = u"SELECT {0}".format(", ".join([u":{0}".format(key) for key in keys]))
69+
query = "SELECT {0}".format(", ".join([":{0}".format(key) for key in keys]))
7070

7171
with self._connect() as conn:
7272
cur = conn.cursor()
@@ -77,8 +77,8 @@ def test_unicode_named_parameter_binding(self):
7777
self.assertResultEqual(val, res)
7878

7979
def test_string_query(self):
80-
value = u'test'
81-
query = u"SELECT '{0}'".format(value)
80+
value = 'test'
81+
query = "SELECT '{0}'".format(value)
8282

8383
with self._connect() as conn:
8484
cur = conn.cursor()
@@ -88,9 +88,9 @@ def test_string_query(self):
8888
self.assertEqual(value, res[0])
8989

9090
def test_string_named_parameter_binding(self):
91-
key = u'test'
92-
value = u'value'
93-
query = u"SELECT :{0}".format(key)
91+
key = 'test'
92+
value = 'value'
93+
query = "SELECT :{0}".format(key)
9494

9595
with self._connect() as conn:
9696
cur = conn.cursor()
@@ -101,9 +101,9 @@ def test_string_named_parameter_binding(self):
101101

102102
# unit test for issue #160
103103
def test_null_named_parameter_binding(self):
104-
key = u'test'
104+
key = 'test'
105105
value = None
106-
query = u"SELECT :{0}".format(key)
106+
query = "SELECT :{0}".format(key)
107107

108108
with self._connect() as conn:
109109
cur = conn.cursor()
@@ -114,8 +114,8 @@ def test_null_named_parameter_binding(self):
114114

115115
# unit test for issue #160
116116
def test_null_list_parameter(self):
117-
values = [u'\u00f1', 'foo', None]
118-
query = u"SELECT {0}".format(", ".join(["%s"] * len(values)))
117+
values = ['\u00f1', 'foo', None]
118+
query = "SELECT {0}".format(", ".join(["%s"] * len(values)))
119119

120120
with self._connect() as conn:
121121
cur = conn.cursor()

‎vertica_python/tests/unit_tests/test_sql_literal.py‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -47,13 +47,13 @@ def test_default_adapters(self):
4747
self.assertEqual(cursor.object_to_sql_literal(datetime.date(2018, 9, 7)), "'2018-09-07'")
4848
self.assertEqual(cursor.object_to_sql_literal(datetime.time(13, 50, 9)), "'13:50:09'")
4949
# String
50-
self.assertEqual(cursor.object_to_sql_literal(u"string'1"), "'string''1'")
50+
self.assertEqual(cursor.object_to_sql_literal("string'1"), "'string''1'")
5151
self.assertEqual(cursor.object_to_sql_literal(b"string'1"), "'string''1'")
5252
# Tuple and namedtuple
5353
self.assertEqual(cursor.object_to_sql_literal(
54-
(123, u"string'1", None)), "(123,'string''1',NULL)")
54+
(123, "string'1", None)), "(123,'string''1',NULL)")
5555
self.assertEqual(cursor.object_to_sql_literal(
56-
((1, u"a"), (2, u"b"), (3, u"c"))), "((1,'a'),(2,'b'),(3,'c'))")
56+
((1, "a"), (2, "b"), (3, "c"))), "((1,'a'),(2,'b'),(3,'c'))")
5757
Point = namedtuple('Point', ['x', 'y', 'z'])
5858
p = Point(x=11, y=22, z=33)
5959
self.assertEqual(cursor.object_to_sql_literal(p), "(11,22,33)")

0 commit comments

Comments
 (0)