def testDeleteAll(self):
keys = [(i, num2words(i)) for i in range(100)]
cxt = tc.Context()
cxt.tree = tc.btree.BTree(SCHEMA)
cxt.inserts = [cxt.tree.insert(key) for key in keys]
cxt.delete = tc.After(cxt.inserts, cxt.tree.delete())
cxt.result = tc.After(cxt.delete, cxt.tree)
result = self.host.post(ENDPOINT, cxt)
self.assertEqual(result, expected([]))
def testDelete(self):
count = 2
values = [(v,) for v in range(count)]
keys = [(num2words(i),) for i in range(count)]
cxt = tc.Context()
cxt.table = tc.table.Table(SCHEMA)
cxt.inserts = [cxt.table.insert(k, v) for k, v in zip(keys, values)]
cxt.delete = tc.After(cxt.inserts, cxt.table.delete())
cxt.result = tc.After(cxt.delete, cxt.table)
result = self.host.post(ENDPOINT, cxt)
self.assertEqual(result, expected(SCHEMA, []))
def testDeleteSlice(self):
count = 50
values = [[v] for v in range(count)]
keys = [[num2words(i)] for i in range(count)]
remaining = sorted([k + v for k, v in zip(keys, values) if v[0] >= 40])
cxt = tc.Context()
cxt.table = tc.table.Table(SCHEMA)
cxt.inserts = [cxt.table.insert(k, v) for k, v in zip(keys, values)]
cxt.delete = tc.After(cxt.inserts,
cxt.table.delete(tc.Map(views=slice(40))))
cxt.result = tc.After(cxt.delete, cxt.table)
result = self.host.post(ENDPOINT, cxt)
self.assertEqual(result, expected(SCHEMA, remaining))
def testCreate(self):
cxt = tc.Context()
cxt.table = tc.table.Table(SCHEMA)
cxt.result = tc.After(cxt.table.insert(("name",), (0,)), cxt.table.count())
count = self.host.post(ENDPOINT, cxt)
self.assertEqual(count, 1)
def testCreate(self):
cxt = tc.Context()
cxt.tree = tc.btree.BTree(SCHEMA)
cxt.result = tc.After(cxt.tree.insert((1, "one")), cxt.tree.count())
count = self.host.post(ENDPOINT, cxt)
self.assertEqual(count, 1)
def testSlice(self):
schema = tc.table.Schema([
tc.Column("0", tc.U64),
tc.Column("1", tc.U64),
tc.Column("2", tc.U64),
tc.Column("3", tc.U64),
], [
tc.Column("value", tc.Number),
])
for i in range(4):
schema.create_index(str(i), [str(i)])
data = [
([0, 0, 1, 0], 1),
([0, 1, 2, 0], 2),
([1, 0, 0, 0], 3),
([1, 0, 1, 0], 3),
]
cxt = tc.Context()
cxt.table = tc.table.Table(schema)
cxt.inserts = [cxt.table.insert(coord, [value]) for (coord, value) in data]
cxt.result = tc.After(cxt.inserts, cxt.table.where({
"0": slice(2),
"1": slice(3),
"2": slice(4),
"3": slice(1)
}))
expect = expected(schema, [coord + [value] for coord, value in data])
actual = self.host.post(ENDPOINT, cxt)
self.assertEqual(actual, expect)
def weigh(self, txn, key: tc.Nil, new_value: tc.Number):
left = tc.use(Left)
txn.total = CONSERVED
txn.current = self.weight.subject()
txn.update = tc.After(self.weight.set(new_value),
left.weigh(None, txn.total - new_value))
return tc.If(txn.current == new_value, None, txn.update)
def buy(self, txn, quantity: tc.Number):
txn.inventory = self.inventory()
txn.new_inventory = txn.inventory - quantity
txn.sale = tc.If(
quantity > txn.inventory,
tc.error.BadRequest("requested quantity is unavailable"),
self.in_stock.set(txn.new_inventory))
return tc.After(self.authorize(SCOPE), txn.sale)
def testSliceRange(self):
keys = [[i, num2words(i)] for i in range(50)]
cxt = tc.Context()
cxt.tree = tc.btree.BTree(SCHEMA)
cxt.inserts = [cxt.tree.insert(key) for key in keys]
cxt.result = tc.After(cxt.inserts, cxt.tree[29:32])
result = self.host.post(ENDPOINT, cxt)
self.assertEqual(result, expected(keys[29:32]))
def recommend(self, txn, user_id: tc.U32):
txn.vector = tc.graph.Vector.create()
txn.user_ids = tc.After(txn.vector[user_id].write(True), txn.vector)
txn.friend_ids = tc.If(
user_id.is_some(), self.friend.match(txn.user_ids, 2),
tc.error.BadRequest("invalid user ID: {{user_id}}",
user_id=user_id))
txn.order_ids = self.user_order.foreign(txn.friend_ids)
txn.product_ids = self.order_product.foreign(txn.order_ids)
return self.product.read_vector(txn.product_ids)
def testSlice(self):
count = 50
values = [(v, ) for v in range(count)]
keys = [(num2words(i), ) for i in range(count)]
cxt = tc.Context()
cxt.table = tc.table.Table(SCHEMA)
cxt.inserts = [cxt.table.insert(k, v) for k, v in zip(keys, values)]
cxt.result = tc.After(cxt.inserts, cxt.table.where({"name": "one"}))
result = self.host.post(ENDPOINT, cxt)
self.assertEqual(result, expected(SCHEMA, [["one", 1]]))
def testGroupBy(self):
count = 50
values = [(v % 2, ) for v in range(count)]
keys = [(num2words(i), ) for i in range(count)]
cxt = tc.Context()
cxt.table = tc.table.Table(SCHEMA)
cxt.inserts = [cxt.table.insert(k, v) for k, v in zip(keys, values)]
cxt.result = tc.After(cxt.inserts, cxt.table.group_by(["views"]))
actual = self.host.post(ENDPOINT, cxt)
self.assertEqual(actual, [[0], [1]])
def testConstant(self):
c = 1.414
shape = [3, 2, 1]
cxt = tc.Context()
cxt.tensor = tc.tensor.Dense.constant(shape, c)
cxt.result = tc.After(cxt.tensor[0, 0, 0].write(0), cxt.tensor)
expected = expect_dense(tc.F64, shape,
[0] + [c] * (np.product(shape) - 1))
actual = self.host.post(ENDPOINT, cxt)
self.assertEqual(expected, actual)
def testCreate(self):
shape = [2, 5]
coord = [0, 0]
value = 1
cxt = tc.Context()
cxt.tensor = tc.tensor.Sparse.zeros(shape, tc.I32)
cxt.result = tc.After(cxt.tensor[coord].write(value), cxt.tensor)
actual = self.host.post(ENDPOINT, cxt)
expected = expect_sparse(tc.I32, shape, [[coord, value]])
self.assertEqual(actual, expected)
def testWriteAndSlice(self):
shape = [2, 5]
cxt = tc.Context()
cxt.tensor = tc.tensor.Sparse.zeros(shape)
cxt.result = tc.After(cxt.tensor[:, 2:-1].write(1), cxt.tensor)
actual = self.host.post(ENDPOINT, cxt)
expected = expect_sparse(
tc.F32, shape,
[[[0, 2], 1], [[0, 3], 1], [[1, 2], 1], [[1, 3], 1]])
self.assertEqual(actual, expected)
def testMul(self):
cxt = tc.Context()
cxt.dense = tc.tensor.Dense.arange([3], 0, 3)
cxt.sparse = tc.tensor.Sparse.zeros([2, 3], tc.I32)
cxt.result = tc.After(cxt.sparse[0, 1:3].write(2),
cxt.dense * cxt.sparse)
actual = self.host.post(ENDPOINT, cxt)
expected = np.zeros([2, 3])
expected[0, 1:3] = 2
expected = expected * np.arange(0, 3)
self.assertEqual(actual, expect_sparse(tc.I64, [2, 3], expected))
def testLimit(self):
count = 50
values = [(v,) for v in range(count)]
keys = [(num2words(i),) for i in range(count)]
cxt = tc.Context()
cxt.table = tc.table.Table(SCHEMA)
cxt.inserts = [cxt.table.insert(k, v) for k, v in zip(keys, values)]
cxt.result = tc.After(cxt.inserts, cxt.table.limit(1))
result = self.host.post(ENDPOINT, cxt)
first_row = sorted(list(k + v) for k, v in zip(keys, values))[0]
self.assertEqual(result, expected(SCHEMA, [first_row]))
def testOrderBy(self):
count = 50
values = [(v, ) for v in range(count)]
keys = [(num2words(i), ) for i in range(count)]
rows = list(reversed([list(k + v) for k, v in zip(keys, values)]))
cxt = tc.Context()
cxt.table = tc.table.Table(SCHEMA)
cxt.inserts = [cxt.table.insert(k, v) for k, v in zip(keys, values)]
cxt.result = tc.After(cxt.inserts, cxt.table.order_by(["views"], True))
result = self.host.post(ENDPOINT, cxt)
self.assertEqual(result, expected(SCHEMA, rows))
def testDeleteSlice(self):
keys = [[i, num2words(i)] for i in range(10)]
ordered = keys[:25] + keys[35:]
random.shuffle(keys)
cxt = tc.Context()
cxt.tree = tc.btree.BTree.load(SCHEMA, ordered)
cxt.delete = cxt.tree.delete([slice(25, 35)])
cxt.result = tc.After(cxt.delete, cxt.tree)
actual = self.host.post(ENDPOINT, cxt)
self.assertEqual(actual, expected(ordered))
def testDiv(self):
self.maxDiff = None
cxt = tc.Context()
cxt.dense = tc.tensor.Dense.arange([30, 3, 2], 1., 181.)
cxt.sparse = tc.tensor.Sparse.zeros([3, 2], tc.F32)
cxt.result = tc.After(cxt.sparse[1].write(2), cxt.sparse / cxt.dense)
actual = self.host.post(ENDPOINT, cxt)
l = np.arange(1, 181).reshape([30, 3, 2])
r = np.zeros([3, 2], float)
r[1] = 2.
expected = r / l
self.assertEqual(actual, expect_sparse(tc.F64, [30, 3, 2], expected))
def testAdd(self):
cxt = tc.Context()
cxt.dense = tc.tensor.Dense.arange([3, 5, 2], 0, 30)
cxt.sparse = tc.tensor.Sparse.zeros([5, 2], tc.I32)
cxt.result = tc.After(cxt.sparse[1].write(3), cxt.dense + cxt.sparse)
actual = self.host.post(ENDPOINT, cxt)
l = np.arange(0, 30).reshape([3, 5, 2])
r = np.zeros([5, 2], np.int32)
r[1] = 3
expected = l + r
self.assertEqual(actual,
expect_dense(tc.I64, [3, 5, 2], expected.flatten()))
def testSliceAndWriteTensor(self):
cxt = tc.Context()
cxt.big = tc.tensor.Dense.zeros([2, 2, 5])
cxt.small = tc.tensor.Dense.arange([2, 5], 1, 11)
cxt.result = tc.After(cxt.big[1, :2].write(cxt.small[0]), cxt.big)
actual = self.host.post(ENDPOINT, cxt)
expected = np.zeros([2, 2, 5], np.int64)
expected[1, 0:2] = np.arange(1, 11).reshape(2, 5)[0]
expected = expect_dense(tc.F64, [2, 2, 5], expected.flatten())
self.assertEqual(actual, expected)
def testSum(self):
shape = [2, 4, 3, 5]
axis = 1
cxt = tc.Context()
cxt.big = tc.tensor.Sparse.zeros(shape, tc.I32)
cxt.result = tc.After(cxt.big[0, 1:3].write(2), cxt.big.sum(axis))
actual = self.host.post(ENDPOINT, cxt)
expected = np.zeros(shape, dtype=np.int32)
expected[0, 1:3] = 2
expected = expected.sum(axis)
expected = expect_sparse(tc.I32, [2, 3, 5], expected)
self.assertEqual(actual, expected)
def testSetDiagonal(self):
size = 3
shape = [size, size]
x = np.arange(0, size**2).reshape(shape)
diag = [2] * size
cxt = tc.Context()
cxt.x = tc.tensor.Dense.load(x.shape, x.flatten().tolist(), tc.I32)
cxt.diag = tc.tensor.Dense.load([size], diag, tc.I32)
cxt.result = tc.After(tc.linalg.set_diagonal(cxt.x, cxt.diag), cxt.x)
x[range(size), range(size)] = diag
actual = self.host.post(ENDPOINT, cxt)
self.assertEqual(actual, expect_dense(x, tc.I32))
def testSliceAndWriteConstant(self):
shape = [2, 5, 3, 3]
cxt = tc.Context()
cxt.tensor = tc.tensor.Dense.arange(shape, 1, 91)
cxt.result = tc.After(cxt.tensor[:, :, 1:-1, 1:-1].write(1),
cxt.tensor)
actual = self.host.post(ENDPOINT, cxt)
expected = np.arange(1, 91).reshape([2, 5, 3, 3])
expected[:, :, 1:-1, 1:-1] = 1
expected = expect_dense(tc.I64, list(expected.shape),
expected.flatten())
self.assertEqual(actual, expected)
def testSliceAuxiliaryIndex(self):
count = 50
values = [(v, ) for v in range(count)]
keys = [(num2words(i), ) for i in range(count)]
cxt = tc.Context()
cxt.table = tc.table.Table(SCHEMA)
cxt.inserts = [cxt.table.insert(k, v) for k, v in zip(keys, values)]
cxt.result = tc.After(cxt.inserts,
cxt.table.where({"views": slice(10, 20)}))
result = self.host.post(ENDPOINT, cxt)
self.assertEqual(
result,
expected(SCHEMA, list([[num2words(i), i] for i in range(10, 20)])))
def testInsert(self):
for x in range(0, 100, 10):
keys = list(range(x))
random.shuffle(keys)
cxt = tc.Context()
cxt.table = tc.table.Table(SCHEMA)
cxt.inserts = [
cxt.table.insert((num2words(i),), (i,))
for i in keys]
cxt.result = tc.After(cxt.inserts, cxt.table.count())
result = self.host.post(ENDPOINT, cxt)
self.assertEqual(result, x)
def testUpdateSlice(self):
count = 50
values = [[v] for v in range(count)]
keys = [[num2words(i)] for i in range(count)]
cxt = tc.Context()
cxt.table = tc.table.Table.load(SCHEMA,
[k + v for k, v in zip(keys, values)])
cxt.update = cxt.table.update({"views": 0}, {"views": slice(10)})
cxt.result = tc.After(cxt.update,
cxt.table.where({
"views": slice(1)
}).count())
result = self.host.post(ENDPOINT, cxt)
self.assertEqual(result, 10)
def testSelect(self):
count = 5
values = [[v] for v in range(count)]
keys = [[num2words(i)] for i in range(count)]
cxt = tc.Context()
cxt.table = tc.table.Table(SCHEMA)
cxt.inserts = [cxt.table.insert(k, v) for k, v in zip(keys, values)]
cxt.result = tc.After(cxt.inserts, cxt.table.select(["name"]))
expected = {
str(tc.URI(tc.table.Table)): [
tc.to_json(tc.table.Schema([tc.Column("name", tc.String, 512)])),
list(sorted(keys))
]
}
actual = self.host.post(ENDPOINT, cxt)
self.assertEqual(actual, expected)
def testSub(self):
shape = [3, 5, 2]
cxt = tc.Context()
cxt.big = tc.tensor.Sparse.zeros(shape, tc.I16)
cxt.small = tc.tensor.Sparse.zeros([5, 2], tc.U32)
cxt.result = tc.After([
cxt.big[:, 1:-2].write(2),
cxt.small[1].write(3),
], cxt.small - cxt.big)
actual = self.host.post(ENDPOINT, cxt)
big = np.zeros(shape)
big[:, 1:-2] = 2
small = np.zeros([5, 2])
small[1] = 3
expected = small - big
expected = expect_sparse(tc.I32, shape, expected)
self.assertEqual(actual, expected)
