def test__merge_chunk_array_of_array_of_string(self):
from google.cloud.spanner_v1 import StructType
from google.cloud.spanner_v1 import Type
from google.cloud.spanner_v1 import TypeCode
subarray_type = Type(code=TypeCode.ARRAY,
array_element_type=Type(code=TypeCode.STRING))
array_type = Type(code=TypeCode.ARRAY,
array_element_type=subarray_type)
iterator = _MockCancellableIterator()
streamed = self._make_one(iterator)
FIELDS = [StructType.Field(name="lolos", type_=array_type)]
streamed._metadata = self._make_result_set_metadata(FIELDS)
streamed._pending_chunk = [
[u"A", u"B"],
[u"C"],
]
chunk = [
[u"D"],
[u"E", u"F"],
]
merged = streamed._merge_chunk(chunk)
expected = [
[u"A", u"B"],
[u"CD"],
[u"E", u"F"],
]
self.assertEqual(merged, expected)
self.assertIsNone(streamed._pending_chunk)
def test_batch_update_error(self):
from google.cloud.spanner_v1 import Type
from google.cloud.spanner_v1 import TypeCode
database = _Database()
api = database.spanner_api = self._make_spanner_api()
api.execute_batch_dml.side_effect = RuntimeError()
session = _Session(database)
transaction = self._make_one(session)
transaction._transaction_id = self.TRANSACTION_ID
insert_dml = "INSERT INTO table(pkey, desc) VALUES (%pkey, %desc)"
insert_params = {"pkey": 12345, "desc": "DESCRIPTION"}
insert_param_types = {
"pkey": Type(code=TypeCode.INT64),
"desc": Type(code=TypeCode.STRING),
}
update_dml = 'UPDATE table SET desc = desc + "-amended"'
delete_dml = "DELETE FROM table WHERE desc IS NULL"
dml_statements = [
(insert_dml, insert_params, insert_param_types),
update_dml,
delete_dml,
]
with self.assertRaises(RuntimeError):
transaction.batch_update(dml_statements)
self.assertEqual(transaction._execute_sql_count, 1)
def test__merge_chunk_array_of_array_of_int(self):
from google.cloud.spanner_v1 import StructType
from google.cloud.spanner_v1 import Type
from google.cloud.spanner_v1 import TypeCode
subarray_type = Type(code=TypeCode.ARRAY,
array_element_type=Type(code=TypeCode.INT64))
array_type = Type(code=TypeCode.ARRAY,
array_element_type=subarray_type)
iterator = _MockCancellableIterator()
streamed = self._make_one(iterator)
FIELDS = [StructType.Field(name="loloi", type_=array_type)]
streamed._metadata = self._make_result_set_metadata(FIELDS)
streamed._pending_chunk = [[0, 1], [2]]
chunk = [[3], [4, 5]]
merged = streamed._merge_chunk(chunk)
expected = [
[0, 1],
[23],
[4, 5],
]
self.assertEqual(merged, expected)
self.assertIsNone(streamed._pending_chunk)
def _make_array_field(name, element_type_code=None, element_type=None):
from google.cloud.spanner_v1 import StructType
from google.cloud.spanner_v1 import Type
from google.cloud.spanner_v1 import TypeCode
if element_type is None:
element_type = Type(code=element_type_code)
array_type = Type(code=TypeCode.ARRAY, array_element_type=element_type)
return StructType.Field(name=name, type_=array_type)
def test_w_array_empty(self):
from google.cloud.spanner_v1 import Type
from google.cloud.spanner_v1 import TypeCode
field_type = Type(code=TypeCode.ARRAY,
array_element_type=Type(code=TypeCode.INT64))
value = []
self.assertEqual(self._callFUT(value, field_type), [])
def test_w_array_empty(self):
from google.protobuf.struct_pb2 import Value, ListValue
from google.cloud.spanner_v1 import Type
from google.cloud.spanner_v1 import TypeCode
field_type = Type(code=TypeCode.ARRAY,
array_element_type=Type(code=TypeCode.INT64))
value_pb = Value(list_value=ListValue(values=[]))
self.assertEqual(self._callFUT(value_pb, field_type), [])
def test_w_array_non_empty(self):
from google.cloud.spanner_v1 import Type
from google.cloud.spanner_v1 import TypeCode
field_type = Type(code=TypeCode.ARRAY,
array_element_type=Type(code=TypeCode.INT64))
values = ["32", "19", "5"]
expected_values = [32, 19, 5]
self.assertEqual(self._callFUT(values, field_type), expected_values)
def test_empty(self):
from google.cloud.spanner_v1 import Type
from google.cloud.spanner_v1 import StructType
from google.cloud.spanner_v1 import TypeCode
struct_type_pb = StructType(fields=[
StructType.Field(name="name", type_=Type(code=TypeCode.STRING)),
StructType.Field(name="age", type_=Type(code=TypeCode.INT64)),
])
self.assertEqual(self._callFUT(rows=[], row_type=struct_type_pb), [])
def _make_struct_type(struct_type_fields):
from google.cloud.spanner_v1 import StructType
from google.cloud.spanner_v1 import Type
from google.cloud.spanner_v1 import TypeCode
fields = [
StructType.Field(name=key, type_=Type(code=value))
for key, value in struct_type_fields
]
struct_type = StructType(fields=fields)
return Type(code=TypeCode.STRUCT, struct_type=struct_type)
def test_it(self):
from google.cloud.spanner_v1 import Type
from google.cloud.spanner_v1 import TypeCode
from google.cloud.spanner_v1 import param_types
expected = Type(code=TypeCode.ARRAY,
array_element_type=Type(code=TypeCode.INT64))
found = param_types.Array(param_types.INT64)
self.assertEqual(found, expected)
def test_w_array_non_empty(self):
from google.protobuf.struct_pb2 import Value, ListValue
from google.cloud.spanner_v1 import Type
from google.cloud.spanner_v1 import TypeCode
field_type = Type(code=TypeCode.ARRAY,
array_element_type=Type(code=TypeCode.INT64))
VALUES = [32, 19, 5]
values_pb = ListValue(
values=[Value(string_value=str(value)) for value in VALUES])
value_pb = Value(list_value=values_pb)
self.assertEqual(self._callFUT(value_pb, field_type), VALUES)
def test_w_struct(self):
from google.cloud.spanner_v1 import Type
from google.cloud.spanner_v1 import StructType
from google.cloud.spanner_v1 import TypeCode
struct_type_pb = StructType(fields=[
StructType.Field(name="name", type_=Type(code=TypeCode.STRING)),
StructType.Field(name="age", type_=Type(code=TypeCode.INT64)),
])
field_type = Type(code=TypeCode.STRUCT, struct_type=struct_type_pb)
values = [u"phred", "32"]
expected_values = [u"phred", 32]
self.assertEqual(self._callFUT(values, field_type), expected_values)
def test_non_empty(self):
from google.cloud.spanner_v1 import Type
from google.cloud.spanner_v1 import StructType
from google.cloud.spanner_v1 import TypeCode
from google.cloud.spanner_v1._helpers import _make_list_value_pbs
VALUES = [[u"phred", 32], [u"bharney", 31]]
struct_type_pb = StructType(fields=[
StructType.Field(name="name", type_=Type(code=TypeCode.STRING)),
StructType.Field(name="age", type_=Type(code=TypeCode.INT64)),
])
values_pbs = _make_list_value_pbs(VALUES)
self.assertEqual(
self._callFUT(rows=values_pbs, row_type=struct_type_pb), VALUES)
def test_w_struct(self):
from google.protobuf.struct_pb2 import Value
from google.cloud.spanner_v1 import Type
from google.cloud.spanner_v1 import StructType
from google.cloud.spanner_v1 import TypeCode
from google.cloud.spanner_v1._helpers import _make_list_value_pb
VALUES = [u"phred", 32]
struct_type_pb = StructType(fields=[
StructType.Field(name="name", type_=Type(code=TypeCode.STRING)),
StructType.Field(name="age", type_=Type(code=TypeCode.INT64)),
])
field_type = Type(code=TypeCode.STRUCT, struct_type=struct_type_pb)
value_pb = Value(list_value=_make_list_value_pb(VALUES))
self.assertEqual(self._callFUT(value_pb, field_type), VALUES)
def test_w_string(self):
from google.cloud.spanner_v1 import Type
from google.cloud.spanner_v1 import TypeCode
field_type = Type(code=TypeCode.STRING)
value = expected_value = u"Value"
self.assertEqual(self._callFUT(value, field_type), expected_value)
def test_w_bool(self):
from google.cloud.spanner_v1 import Type
from google.cloud.spanner_v1 import TypeCode
field_type = Type(code=TypeCode.BOOL)
value = expected_value = True
self.assertEqual(self._callFUT(value, field_type), expected_value)
def test_w_null(self):
from google.protobuf.struct_pb2 import Value, NULL_VALUE
from google.cloud.spanner_v1 import Type
from google.cloud.spanner_v1 import TypeCode
field_type = Type(code=TypeCode.STRING)
value_pb = Value(null_value=NULL_VALUE)
self.assertEqual(self._callFUT(value_pb, field_type), None)
def test_w_unknown_type(self):
from google.cloud.spanner_v1 import Type
from google.cloud.spanner_v1 import TypeCode
field_type = Type(code=TypeCode.TYPE_CODE_UNSPECIFIED)
value_pb = object()
with self.assertRaises(ValueError):
self._callFUT(value_pb, field_type)
def test_w_float(self):
from google.cloud.spanner_v1 import Type
from google.cloud.spanner_v1 import TypeCode
field_type = Type(code=TypeCode.FLOAT64)
value = "3.14159"
expected_value = 3.14159
self.assertEqual(self._callFUT(value, field_type), expected_value)
def test_w_int(self):
from google.cloud.spanner_v1 import Type
from google.cloud.spanner_v1 import TypeCode
field_type = Type(code=TypeCode.INT64)
value = "12345"
expected_value = 12345
self.assertEqual(self._callFUT(value, field_type), expected_value)
def test_w_bytes(self):
from google.cloud.spanner_v1 import Type
from google.cloud.spanner_v1 import TypeCode
field_type = Type(code=TypeCode.BYTES)
value = "Value"
expected_value = b"Value"
self.assertEqual(self._callFUT(value, field_type), expected_value)
def test_it(self):
from google.cloud.spanner_v1 import Type
from google.cloud.spanner_v1 import TypeCode
from google.cloud.spanner_v1 import StructType
from google.cloud.spanner_v1 import param_types
struct_type = StructType(fields=[
StructType.Field(name="name", type_=Type(code=TypeCode.STRING)),
StructType.Field(name="count", type_=Type(code=TypeCode.INT64)),
])
expected = Type(code=TypeCode.STRUCT, struct_type=struct_type)
found = param_types.Struct([
param_types.StructField("name", param_types.STRING),
param_types.StructField("count", param_types.INT64),
])
self.assertEqual(found, expected)
def test_w_empty_value(self):
from google.protobuf.struct_pb2 import Value
from google.cloud.spanner_v1 import Type
from google.cloud.spanner_v1 import TypeCode
field_type = Type(code=TypeCode.STRING)
value_pb = Value()
with self.assertRaises(ValueError):
self._callFUT(value_pb, field_type)
def test_w_unknown_type(self):
from google.protobuf.struct_pb2 import Value
from google.cloud.spanner_v1 import Type
from google.cloud.spanner_v1 import TypeCode
field_type = Type(code=TypeCode.TYPE_CODE_UNSPECIFIED)
value_pb = Value(string_value="Borked")
with self.assertRaises(ValueError):
self._callFUT(value_pb, field_type)
def test_w_float(self):
from google.protobuf.struct_pb2 import Value
from google.cloud.spanner_v1 import Type
from google.cloud.spanner_v1 import TypeCode
VALUE = 3.14159
field_type = Type(code=TypeCode.FLOAT64)
value_pb = Value(number_value=VALUE)
self.assertEqual(self._callFUT(value_pb, field_type), VALUE)
def test_w_int(self):
from google.protobuf.struct_pb2 import Value
from google.cloud.spanner_v1 import Type
from google.cloud.spanner_v1 import TypeCode
VALUE = 12345
field_type = Type(code=TypeCode.INT64)
value_pb = Value(string_value=str(VALUE))
self.assertEqual(self._callFUT(value_pb, field_type), VALUE)
def test_w_bool(self):
from google.protobuf.struct_pb2 import Value
from google.cloud.spanner_v1 import Type
from google.cloud.spanner_v1 import TypeCode
VALUE = True
field_type = Type(code=TypeCode.BOOL)
value_pb = Value(bool_value=VALUE)
self.assertEqual(self._callFUT(value_pb, field_type), VALUE)
def test_w_bytes(self):
from google.protobuf.struct_pb2 import Value
from google.cloud.spanner_v1 import Type
from google.cloud.spanner_v1 import TypeCode
VALUE = b"Value"
field_type = Type(code=TypeCode.BYTES)
value_pb = Value(string_value=VALUE)
self.assertEqual(self._callFUT(value_pb, field_type), VALUE)
def test_w_numeric(self):
import decimal
from google.cloud.spanner_v1 import Type
from google.cloud.spanner_v1 import TypeCode
field_type = Type(code=TypeCode.NUMERIC)
expected_value = decimal.Decimal("99999999999999999999999999999.999999999")
value = "99999999999999999999999999999.999999999"
self.assertEqual(self._callFUT(value, field_type), expected_value)
def test_w_date(self):
import datetime
from google.cloud.spanner_v1 import Type
from google.cloud.spanner_v1 import TypeCode
value = "2020-09-22"
expected_value = datetime.date(2020, 9, 22)
field_type = Type(code=TypeCode.DATE)
self.assertEqual(self._callFUT(value, field_type), expected_value)
