def testBasicSpellCheckWithNoResult():
env = Env()
env.cmd('ft.create', 'idx', 'SCHEMA', 'name', 'TEXT', 'body', 'TEXT')
env.cmd('ft.add', 'idx', 'doc1', 1.0, 'FIELDS', 'name', 'name1', 'body', 'body1')
env.cmd('ft.add', 'idx', 'doc2', 1.0, 'FIELDS', 'name', 'name2', 'body', 'body2')
env.cmd('ft.add', 'idx', 'doc3', 1.0, 'FIELDS', 'name', 'name2', 'body', 'name2')
env.expect('ft.spellcheck', 'idx', 'somenotexiststext').equal([['TERM', 'somenotexiststext', []]])
def testSpellCheckOnExistingTerm():
env = Env()
env.cmd('ft.create', 'idx', 'SCHEMA', 'name', 'TEXT', 'body', 'TEXT')
env.cmd('ft.add', 'idx', 'doc1', 1.0, 'FIELDS', 'name', 'name', 'body', 'body1')
env.cmd('ft.add', 'idx', 'doc2', 1.0, 'FIELDS', 'name', 'name2', 'body', 'body2')
env.cmd('ft.add', 'idx', 'doc3', 1.0, 'FIELDS', 'name', 'name2', 'body', 'name2')
env.expect('ft.spellcheck', 'idx', 'name').equal([])
def testSpellCheckNoneExistingDicts():
env = Env()
env.cmd('ft.create', 'idx', 'SCHEMA', 'name', 'TEXT', 'body', 'TEXT')
env.cmd('ft.add', 'idx', 'doc1', 1.0, 'FIELDS', 'name', 'name1', 'body', 'body1')
env.cmd('ft.add', 'idx', 'doc2', 1.0, 'FIELDS', 'name', 'name2', 'body', 'body2')
env.cmd('ft.add', 'idx', 'doc3', 1.0, 'FIELDS', 'name', 'name2', 'body', 'name2')
env.expect('ft.spellcheck', 'idx', 'name', 'TERMS', 'INCLUDE', 'dict').raiseError()
env.expect('ft.spellcheck', 'idx', 'name', 'TERMS', 'EXCLUDE', 'dict').raiseError()
def testSpellCheckIssue437():
env = Env()
env.cmd('ft.create', 'incidents', 'SCHEMA', 'report', 'text')
env.cmd('FT.DICTADD', 'slang', 'timmies', 'toque', 'toonie', 'serviette', 'kerfuffle', 'chesterfield')
env.expect('FT.SPELLCHECK', 'incidents',
'Tooni toque kerfuffle', 'TERMS',
'EXCLUDE', 'slang', 'TERMS',
'INCLUDE', 'slang').equal([['TERM', 'tooni', [['0', 'toonie']]]])
class TestAggregateSecondUseCases():
def __init__(self):
self.env = Env()
add_values(self.env, 2)
def testSimpleAggregate(self):
res = self.env.cmd('ft.aggregate', 'games', '*')
self.env.assertIsNotNone(res)
self.env.assertEqual(len(res), 4531)
def testSimpleAggregateWithCursor(self):
res = self.env.cmd('ft.aggregate', 'games', '*', 'WITHCURSOR', 'COUNT', 1000)
self.env.assertTrue(res[1] != 0)
def testSpellCheckNoneExistingIndex():
env = Env()
env.expect('ft.spellcheck', 'idx', 'name', 'TERMS', 'EXCLUDE', 'dict').raiseError()
def testAofRewriteTags():
env = Env(useAof=True)
conn = getConnectionByEnv(env)
env.cmd('FT.CREATE', 'idx', 'ON', 'HASH', 'SCHEMA', 'foo', 'TEXT',
'SORTABLE', 'bar', 'TAG')
env.cmd('FT.ADD', 'idx', '1', '1', 'FIELDS', 'foo', 'A', 'bar', '1')
env.cmd('FT.ADD', 'idx', '2', '1', 'fields', 'foo', 'B', 'bar', '1')
info_a = to_dict(env.cmd('FT.INFO', 'idx'))
env.restart_and_reload()
info_b = to_dict(env.cmd('FT.INFO', 'idx'))
env.assertEqual(info_a['fields'], info_b['fields'])
# Try to drop the schema
env.cmd('FT.DROP', 'idx')
conn.execute_command('del', '1')
conn.execute_command('del', '2')
# Try to create it again - should work!
env.cmd('FT.CREATE', 'idx', 'ON', 'HASH', 'SCHEMA', 'foo', 'TEXT',
'SORTABLE', 'bar', 'TAG')
env.cmd('FT.ADD', 'idx', '1', '1', 'FIELDS', 'foo', 'A', 'bar', '1')
env.cmd('FT.ADD', 'idx', '2', '1', 'fields', 'foo', 'B', 'bar', '1')
res = env.cmd('FT.SEARCH', 'idx', '@bar:{1}', 'SORTBY', 'foo', 'ASC',
'RETURN', '1', 'foo', 'WITHSORTKEYS')
env.assertEqual([2L, '1', '$a', ['foo', 'A'], '2', '$b', ['foo', 'B']],
res)
def testAofRewriteTags():
env = Env(useAof=True)
env.cmd('FT.CREATE', 'idx', 'SCHEMA', 'foo',
'TEXT', 'SORTABLE', 'bar', 'TAG')
env.cmd('FT.ADD', 'idx', '1', '1', 'FIELDS', 'foo', 'A', 'bar', '1')
env.cmd('FT.ADD', 'idx', '2', '1', 'fields', 'foo', 'B', 'bar', '1')
info_a = to_dict(env.cmd('FT.INFO', 'idx'))
env.restart_and_reload()
info_b = to_dict(env.cmd('FT.INFO', 'idx'))
env.assertEqual(info_a['fields'], info_b['fields'])
# Try to drop the schema
env.cmd('FT.DROP', 'idx')
# Try to create it again - should work!
env.cmd('FT.CREATE', 'idx', 'SCHEMA', 'foo',
'TEXT', 'SORTABLE', 'bar', 'TAG')
env.cmd('FT.ADD', 'idx', '1', '1', 'FIELDS', 'foo', 'A', 'bar', '1')
env.cmd('FT.ADD', 'idx', '2', '1', 'fields', 'foo', 'B', 'bar', '1')
res = env.cmd('FT.SEARCH', 'idx', '@bar:{1}', 'SORTBY', 'foo', 'ASC',
'RETURN', '1', 'foo', 'WITHSORTKEYS')
env.assertEqual([2L, '1', '$a', ['foo', 'A'],
'2', '$b', ['foo', 'B']], res)
def testAof():
env = Env(useAof=True)
aofTestCommon(env, lambda: env.restart_and_reload())
def __init__(self):
self.env = Env()
add_values(self.env, 2)
class testPendingQueryLimit():
def __init__(self):
self.env = Env(decodeResponses=True)
# skip test if we're running under Valgrind
if self.env.envRunner.debugger is not None or os.getenv('COV') == '1':
self.env.skip(
) # valgrind is not working correctly with multi process
self.conn = self.env.getConnection()
def stress_server(self):
threadpool_size = self.conn.execute_command("GRAPH.CONFIG", "GET",
"THREAD_COUNT")[1]
thread_count = threadpool_size * 5
qs = [SLOW_QUERY] * thread_count
connections = []
pool = Pool(nodes=thread_count)
# init connections
for i in range(thread_count):
connections.append(self.env.getConnection())
# invoke queries
result = pool.map(issue_query, connections, qs)
# return if error encountered
return any(result)
def test_01_query_limit_config(self):
# read max queued queries config
result = self.conn.execute_command("GRAPH.CONFIG", "GET",
"MAX_QUEUED_QUERIES")
max_queued_queries = result[1]
self.env.assertEquals(max_queued_queries, 4294967295)
# update configuration, set max queued queries
self.conn.execute_command("GRAPH.CONFIG", "SET", "MAX_QUEUED_QUERIES",
10)
# re-read configuration
result = self.conn.execute_command("GRAPH.CONFIG", "GET",
"MAX_QUEUED_QUERIES")
max_queued_queries = result[1]
self.env.assertEquals(max_queued_queries, 10)
def test_02_overflow_no_limit(self):
# no limit on number of pending queries
limit = 4294967295
self.conn.execute_command("GRAPH.CONFIG", "SET", "MAX_QUEUED_QUERIES",
limit)
error_encountered = self.stress_server()
self.env.assertFalse(error_encountered)
def test_03_overflow_with_limit(self):
# limit number of pending queries
limit = 1
self.conn.execute_command("GRAPH.CONFIG", "SET", "MAX_QUEUED_QUERIES",
limit)
error_encountered = self.stress_server()
self.env.assertTrue(error_encountered)
def testGCShutDownOnExit(env):
if env.env == 'existing-env' or env.env == 'enterprise' or env.isCluster(
) or platform.system() == 'Darwin':
env.skip()
env.expect('ft.config', 'set', 'FORK_GC_CLEAN_THRESHOLD', 0).equal('OK')
env = Env(moduleArgs='GC_POLICY FORK FORKGC_SLEEP_BEFORE_EXIT 20')
env.assertOk(
env.execute_command('ft.config', 'set', 'FORK_GC_CLEAN_THRESHOLD', 0))
env.expect('FT.CREATE', 'idx', 'ON', 'HASH', 'SCHEMA', 'title', 'TEXT',
'SORTABLE').ok()
env.expect('FT.DEBUG', 'GC_FORCEBGINVOKE', 'idx').ok()
env.stop()
env.start()
# make sure server started successfully
env.expect('FT.CREATE', 'idx', 'ON', 'HASH', 'SCHEMA', 'title', 'TEXT',
'SORTABLE').ok()
class TestAggregate():
def __init__(self):
self.env = Env()
add_values(self.env)
def testGroupBy(self):
cmd = [
'ft.aggregate', 'games', '*', 'GROUPBY', '1', '@brand', 'REDUCE',
'count', '0', 'AS', 'count', 'SORTBY', 2, '@count', 'desc',
'LIMIT', '0', '5'
]
res = self.env.cmd(*cmd)
self.env.assertIsNotNone(res)
self.env.assertEqual([
292L, ['brand', '', 'count', '1518'],
['brand', 'mad catz', 'count', '43'],
['brand', 'generic', 'count', '40'],
['brand', 'steelseries', 'count', '37'],
['brand', 'logitech', 'count', '35']
], res)
def testMinMax(self):
cmd = [
'ft.aggregate', 'games', 'sony', 'GROUPBY', '1', '@brand',
'REDUCE', 'count', '0', 'REDUCE', 'min', '1', '@price', 'as',
'minPrice', 'SORTBY', '2', '@minPrice', 'DESC'
]
res = self.env.cmd(*cmd)
self.env.assertIsNotNone(res)
row = to_dict(res[1])
self.env.assertEqual(88, int(float(row['minPrice'])))
cmd = [
'ft.aggregate', 'games', 'sony', 'GROUPBY', '1', '@brand',
'REDUCE', 'count', '0', 'REDUCE', 'max', '1', '@price', 'as',
'maxPrice', 'SORTBY', '2', '@maxPrice', 'DESC'
]
res = self.env.cmd(*cmd)
row = to_dict(res[1])
self.env.assertEqual(695, int(float(row['maxPrice'])))
def testAvg(self):
cmd = [
'ft.aggregate', 'games', 'sony', 'GROUPBY', '1', '@brand',
'REDUCE', 'avg', '1', '@price', 'AS', 'avg_price', 'REDUCE',
'count', '0', 'SORTBY', '2', '@avg_price', 'DESC'
]
res = self.env.cmd(*cmd)
self.env.assertIsNotNone(res)
self.env.assertEqual(26, res[0])
# Ensure the formatting actually exists
first_row = to_dict(res[1])
self.env.assertEqual(109, int(float(first_row['avg_price'])))
for row in res[1:]:
row = to_dict(row)
self.env.assertIn('avg_price', row)
# Test aliasing
cmd = [
'FT.AGGREGATE', 'games', 'sony', 'GROUPBY', '1', '@brand',
'REDUCE', 'avg', '1', '@price', 'AS', 'avgPrice'
]
res = self.env.cmd(*cmd)
first_row = to_dict(res[1])
self.env.assertEqual(17, int(float(first_row['avgPrice'])))
def testCountDistinct(self):
cmd = [
'FT.AGGREGATE', 'games', '*', 'GROUPBY', '1', '@brand', 'REDUCE',
'COUNT_DISTINCT', '1', '@title', 'AS', 'count_distinct(title)',
'REDUCE', 'COUNT', '0'
]
res = self.env.cmd(*cmd)[1:]
# print res
row = to_dict(res[0])
self.env.assertEqual(1484, int(row['count_distinct(title)']))
cmd = [
'FT.AGGREGATE', 'games', '*', 'GROUPBY', '1', '@brand', 'REDUCE',
'COUNT_DISTINCTISH', '1', '@title', 'AS',
'count_distinctish(title)', 'REDUCE', 'COUNT', '0'
]
res = self.env.cmd(*cmd)[1:]
# print res
row = to_dict(res[0])
self.env.assertEqual(1461, int(row['count_distinctish(title)']))
def testQuantile(self):
cmd = [
'FT.AGGREGATE', 'games', '*', 'GROUPBY', '1', '@brand', 'REDUCE',
'QUANTILE', '2', '@price', '0.50', 'AS', 'q50', 'REDUCE',
'QUANTILE', '2', '@price', '0.90', 'AS', 'q90', 'REDUCE',
'QUANTILE', '2', '@price', '0.95', 'AS', 'q95', 'REDUCE', 'AVG',
'1', '@price', 'REDUCE', 'COUNT', '0', 'AS', 'rowcount', 'SORTBY',
'2', '@rowcount', 'DESC', 'MAX', '1'
]
res = self.env.cmd(*cmd)
row = to_dict(res[1])
# TODO: Better samples
self.env.assertAlmostEqual(14.99, float(row['q50']), delta=3)
self.env.assertAlmostEqual(70, float(row['q90']), delta=50)
self.env.assertAlmostEqual(110, (float(row['q95'])), delta=50)
def testStdDev(self):
cmd = [
'FT.AGGREGATE', 'games', '*', 'GROUPBY', '1', '@brand', 'REDUCE',
'STDDEV', '1', '@price', 'AS', 'stddev(price)', 'REDUCE', 'AVG',
'1', '@price', 'AS', 'avgPrice', 'REDUCE', 'QUANTILE', '2',
'@price', '0.50', 'AS', 'q50Price', 'REDUCE', 'COUNT', '0', 'AS',
'rowcount', 'SORTBY', '2', '@rowcount', 'DESC', 'LIMIT', '0', '10'
]
res = self.env.cmd(*cmd)
row = to_dict(res[1])
self.env.assertTrue(10 <= int(float(row['q50Price'])) <= 20)
self.env.assertAlmostEqual(53,
int(float(row['stddev(price)'])),
delta=50)
self.env.assertEqual(29, int(float(row['avgPrice'])))
def testParseTime(self):
cmd = [
'FT.AGGREGATE', 'games', '*', 'GROUPBY', '1', '@brand', 'REDUCE',
'COUNT', '0', 'AS', 'count', 'APPLY', 'timefmt(1517417144)', 'AS',
'dt', 'APPLY', 'parse_time("%FT%TZ", @dt)', 'as', 'parsed_dt',
'LIMIT', '0', '1'
]
res = self.env.cmd(*cmd)
self.env.assertEqual([
'brand', '', 'count', '1518', 'dt', '2018-01-31T16:45:44Z',
'parsed_dt', '1517417144'
], res[1])
def testRandomSample(self):
cmd = [
'FT.AGGREGATE', 'games', '*', 'GROUPBY', '1', '@brand', 'REDUCE',
'COUNT', '0', 'AS', 'num', 'REDUCE', 'RANDOM_SAMPLE', '2',
'@price', '10', 'SORTBY', '2', '@num', 'DESC', 'MAX', '10'
]
for row in self.env.cmd(*cmd)[1:]:
self.env.assertIsInstance(row[5], list)
self.env.assertGreater(len(row[5]), 0)
self.env.assertGreaterEqual(row[3], len(row[5]))
self.env.assertLessEqual(len(row[5]), 10)
def testTimeFunctions(self):
cmd = [
'FT.AGGREGATE', 'games', '*', 'APPLY', '1517417144', 'AS', 'dt',
'APPLY', 'timefmt(@dt)', 'AS', 'timefmt', 'APPLY', 'day(@dt)',
'AS', 'day', 'APPLY', 'hour(@dt)', 'AS', 'hour', 'APPLY',
'minute(@dt)', 'AS', 'minute', 'APPLY', 'month(@dt)', 'AS',
'month', 'APPLY', 'dayofweek(@dt)', 'AS', 'dayofweek', 'APPLY',
'dayofmonth(@dt)', 'AS', 'dayofmonth', 'APPLY', 'dayofyear(@dt)',
'AS', 'dayofyear', 'APPLY', 'year(@dt)', 'AS', 'year', 'LIMIT',
'0', '1'
]
res = self.env.cmd(*cmd)
self.env.assertListEqual([
1L,
[
'dt', '1517417144', 'timefmt', '2018-01-31T16:45:44Z', 'day',
'1517356800', 'hour', '1517414400', 'minute', '1517417100',
'month', '1514764800', 'dayofweek', '3', 'dayofmonth', '31',
'dayofyear', '30', 'year', '2018'
]
], res)
def testStringFormat(self):
cmd = [
'FT.AGGREGATE', 'games', '@brand:sony', 'GROUPBY', '2', '@title',
'@brand', 'REDUCE', 'COUNT', '0', 'REDUCE', 'MAX', '1', '@price',
'AS', 'price', 'APPLY',
'format("%s|%s|%s|%s", @title, @brand, "Mark", @price)', 'as',
'titleBrand', 'LIMIT', '0', '10'
]
res = self.env.cmd(*cmd)
for row in res[1:]:
row = to_dict(row)
expected = '%s|%s|%s|%g' % (row['title'], row['brand'], 'Mark',
float(row['price']))
self.env.assertEqual(expected, row['titleBrand'])
def testSum(self):
cmd = [
'ft.aggregate', 'games', '*', 'GROUPBY', '1', '@brand', 'REDUCE',
'count', '0', 'AS', 'count', 'REDUCE', 'sum', 1, '@price', 'AS',
'sum(price)', 'SORTBY', 2, '@sum(price)', 'desc', 'LIMIT', '0', '5'
]
res = self.env.cmd(*cmd)
self.env.assertEqual([
292L, ['brand', '', 'count', '1518', 'sum(price)', '44780.69'],
['brand', 'mad catz', 'count', '43', 'sum(price)', '3973.48'],
['brand', 'razer', 'count', '26', 'sum(price)', '2558.58'],
['brand', 'logitech', 'count', '35', 'sum(price)', '2329.21'],
['brand', 'steelseries', 'count', '37', 'sum(price)', '1851.12']
], res)
def testFilter(self):
cmd = [
'ft.aggregate', 'games', '*', 'GROUPBY', '1', '@brand', 'REDUCE',
'count', '0', 'AS', 'count', 'FILTER', '@count > 5'
]
res = self.env.cmd(*cmd)
for row in res[1:]:
row = to_dict(row)
self.env.assertGreater(int(row['count']), 5)
cmd = [
'ft.aggregate', 'games', '*', 'GROUPBY', '1', '@brand', 'REDUCE',
'count', '0', 'AS', 'count', 'FILTER', '@count < 5', 'FILTER',
'@count > 2 && @brand != ""'
]
res = self.env.cmd(*cmd)
for row in res[1:]:
row = to_dict(row)
self.env.assertLess(int(row['count']), 5)
self.env.assertGreater(int(row['count']), 2)
def testToList(self):
cmd = [
'ft.aggregate', 'games', '*', 'GROUPBY', '1', '@brand', 'REDUCE',
'count_distinct', '1', '@price', 'as', 'count', 'REDUCE', 'tolist',
1, '@price', 'as', 'prices', 'SORTBY', 2, '@count', 'desc',
'LIMIT', '0', '5'
]
res = self.env.cmd(*cmd)
for row in res[1:]:
row = to_dict(row)
self.env.assertEqual(int(row['count']), len(row['prices']))
def testSortBy(self):
res = self.env.cmd('ft.aggregate', 'games', '*', 'GROUPBY', '1',
'@brand', 'REDUCE', 'sum', 1, '@price', 'as',
'price', 'SORTBY', 2, '@price', 'desc', 'LIMIT',
'0', '2')
self.env.assertListEqual([
292L, ['brand', '', 'price', '44780.69'],
['brand', 'mad catz', 'price', '3973.48']
], res)
res = self.env.cmd('ft.aggregate', 'games', '*', 'GROUPBY', '1',
'@brand', 'REDUCE', 'sum', 1, '@price', 'as',
'price', 'SORTBY', 2, '@price', 'asc', 'LIMIT', '0',
'2')
self.env.assertListEqual([
292L, ['brand', 'myiico', 'price', '0.23'],
['brand', 'crystal dynamics', 'price', '0.25']
], res)
# Test MAX with limit higher than it
res = self.env.cmd('ft.aggregate', 'games', '*', 'GROUPBY', '1',
'@brand', 'REDUCE', 'sum', 1, '@price', 'as',
'price', 'SORTBY', 2, '@price', 'asc', 'MAX', 2)
self.env.assertListEqual([
292L, ['brand', 'myiico', 'price', '0.23'],
['brand', 'crystal dynamics', 'price', '0.25']
], res)
# Test Sorting by multiple properties
res = self.env.cmd(
'ft.aggregate',
'games',
'*',
'GROUPBY',
'1',
'@brand',
'REDUCE',
'sum',
1,
'@price',
'as',
'price',
'APPLY',
'(@price % 10)',
'AS',
'price',
'SORTBY',
4,
'@price',
'asc',
'@brand',
'desc',
'MAX',
10,
)
self.env.assertListEqual([
292L, ['brand', 'zps', 'price', '0'],
['brand', 'zalman', 'price', '0'], [
'brand', 'yoozoo', 'price', '0'
], ['brand', 'white label', 'price', '0'],
['brand', 'stinky', 'price', '0'],
['brand', 'polaroid', 'price', '0'],
['brand', 'plantronics', 'price', '0'],
['brand', 'ozone', 'price', '0'], ['brand', 'oooo', 'price', '0'],
['brand', 'neon', 'price', '0']
], res)
def testExpressions(self):
pass
def testNoGroup(self):
res = self.env.cmd(
'ft.aggregate',
'games',
'*',
'LOAD',
'2',
'@brand',
'@price',
'APPLY',
'floor(sqrt(@price)) % 10',
'AS',
'price',
'SORTBY',
4,
'@price',
'desc',
'@brand',
'desc',
'MAX',
5,
)
exp = [
2265L, ['brand', 'Xbox', 'price', '9'],
['brand', 'turtle beach', 'price', '9'],
['brand', 'trust', 'price', '9'],
['brand', 'steelseries', 'price', '9'],
['brand', 'speedlink', 'price', '9']
]
# exp = [2265L, ['brand', 'Xbox', 'price', '9'], ['brand', 'Turtle Beach', 'price', '9'], [
# 'brand', 'Trust', 'price', '9'], ['brand', 'SteelSeries', 'price', '9'], ['brand', 'Speedlink', 'price', '9']]
self.env.assertListEqual(exp[1], res[1])
def testLoad(self):
res = self.env.cmd('ft.aggregate', 'games', '*', 'LOAD', '3', '@brand',
'@price', '@nonexist', 'SORTBY', 2, '@price',
'DESC', 'MAX', 2)
exp = [
3L, ['brand', '', 'price', '759.12'],
['brand', 'Sony', 'price', '695.8']
]
self.env.assertEqual(exp[1], res[1])
def testSplit(self):
res = self.env.cmd(
'ft.aggregate', 'games', '*', 'APPLY',
'split("hello world, foo,,,bar,", ",", " ")', 'AS', 'strs',
'APPLY', 'split("hello world, foo,,,bar,", " ", ",")', 'AS',
'strs2', 'APPLY', 'split("hello world, foo,,,bar,", "", "")',
'AS', 'strs3', 'APPLY', 'split("hello world, foo,,,bar,")', 'AS',
'strs4', 'APPLY', 'split("hello world, foo,,,bar,",",")', 'AS',
'strs5', 'APPLY', 'split("")', 'AS', 'empty', 'LIMIT', '0', '1')
# print "Got {} results".format(len(res))
# return
# pprint.pprint(res)
self.env.assertListEqual([
1L,
[
'strs', ['hello world', 'foo', 'bar'], 'strs2',
['hello', 'world', 'foo,,,bar'], 'strs3',
['hello world, foo,,,bar,'], 'strs4',
['hello world', 'foo', 'bar'], 'strs5',
['hello world', 'foo', 'bar'], 'empty', []
]
], res)
def testFirstValue(self):
res = self.env.cmd(
'ft.aggregate', 'games',
'@brand:(sony|matias|beyerdynamic|(mad catz))', 'GROUPBY', 1,
'@brand', 'REDUCE', 'FIRST_VALUE', 4, '@title', 'BY', '@price',
'DESC', 'AS', 'top_item', 'REDUCE', 'FIRST_VALUE', 4, '@price',
'BY', '@price', 'DESC', 'AS', 'top_price', 'REDUCE', 'FIRST_VALUE',
4, '@title', 'BY', '@price', 'ASC', 'AS', 'bottom_item', 'REDUCE',
'FIRST_VALUE', 4, '@price', 'BY', '@price', 'ASC', 'AS',
'bottom_price', 'SORTBY', 2, '@top_price', 'DESC', 'MAX', 5)
expected = [
4L,
[
'brand', 'sony', 'top_item',
'sony psp slim & lite 2000 console', 'top_price', '695.8',
'bottom_item',
'sony dlchd20p high speed hdmi cable for playstation 3',
'bottom_price', '5.88'
],
[
'brand', 'matias', 'top_item', 'matias halfkeyboard usb',
'top_price', '559.99', 'bottom_item',
'matias halfkeyboard usb', 'bottom_price', '559.99'
],
[
'brand', 'beyerdynamic', 'top_item',
'beyerdynamic mmx300 pc gaming premium digital headset with microphone',
'top_price', '359.74', 'bottom_item',
'beyerdynamic headzone pc gaming digital surround sound system with mmx300 digital headset with microphone',
'bottom_price', '0'
],
[
'brand', 'mad catz', 'top_item',
'mad catz s.t.r.i.k.e.7 gaming keyboard', 'top_price',
'295.95', 'bottom_item',
'madcatz mov4545 xbox replacement breakaway cable',
'bottom_price', '3.49'
]
]
# hack :(
def mklower(result):
for arr in result[1:]:
for x in range(len(arr)):
arr[x] = arr[x].lower()
mklower(expected)
mklower(res)
self.env.assertListEqual(expected, res)
def testLoadAfterGroupBy(self):
with self.env.assertResponseError():
self.env.cmd('ft.aggregate', 'games', '*', 'GROUPBY', 1, '@brand',
'LOAD', 1, '@brand')
def testReducerGeneratedAliasing(self):
rv = self.env.cmd('ft.aggregate', 'games', '*', 'GROUPBY', 1, '@brand',
'REDUCE', 'MIN', 1, '@price', 'LIMIT', 0, 1)
self.env.assertEqual(
[292L, ['brand', '', '__generated_aliasminprice', '0']], rv)
rv = self.env.cmd('ft.aggregate', 'games',
'@brand:(sony|matias|beyerdynamic|(mad catz))',
'GROUPBY', 1, '@brand', 'REDUCE', 'FIRST_VALUE', 4,
'@title', 'BY', '@price', 'DESC', 'SORTBY', 2,
'@brand', 'ASC')
self.env.assertEqual('__generated_aliasfirst_valuetitle,by,price,desc',
rv[1][2])
def testIssue1125(self):
rv = self.env.cmd('ft.aggregate', 'games', '*', 'LIMIT', 0, 20000000)
self.env.assertEqual(2266, len(rv))
# SEARCH should fail
self.env.expect('ft.search', 'games', '*', 'limit', 0, 2000000).error() \
.contains('LIMIT exceeds maximum of 1000000')
def testGCThreshold(env):
if env.env == 'existing-env':
env.skip()
if env.isCluster():
raise unittest.SkipTest()
env = Env(moduleArgs='GC_POLICY FORK FORK_GC_CLEAN_THRESHOLD 1000')
env.expect('FT.CREATE', 'idx', 'ON', 'HASH', 'SCHEMA', 'title', 'TEXT',
'SORTABLE').ok()
for i in range(1000):
env.expect('FT.ADD', 'idx', 'doc%d' % i, '1.0', 'FIELDS', 'title',
'foo').ok()
debug_rep = env.cmd('FT.DEBUG', 'DUMP_INVIDX', 'idx', 'foo')
for i in range(999):
env.expect('FT.DEL', 'idx', 'doc%d' % i).equal(1)
env.cmd('ft.debug', 'GC_FORCEINVOKE', 'idx')
env.expect('FT.DEBUG', 'DUMP_INVIDX', 'idx', 'foo').equal(debug_rep)
env.expect('FT.DEL', 'idx', 'doc999').equal(1)
env.cmd('ft.debug', 'GC_FORCEINVOKE', 'idx')
debug_rep = env.cmd('FT.DEBUG', 'DUMP_INVIDX', 'idx', 'foo')
env.assertEqual(len(debug_rep), 0)
# retry with replace
for i in range(1000):
env.expect('FT.ADD', 'idx', 'doc%d' % i, '1.0', 'FIELDS', 'title',
'foo').ok()
debug_rep = env.cmd('FT.DEBUG', 'DUMP_INVIDX', 'idx', 'foo')
for i in range(999):
env.expect('FT.ADD', 'idx', 'doc%d' % i, '1.0', 'REPLACE', 'FIELDS',
'title', 'foo1').ok()
env.cmd('ft.debug', 'GC_FORCEINVOKE', 'idx')
env.expect('FT.DEBUG', 'DUMP_INVIDX', 'idx', 'foo').equal(debug_rep)
env.expect('FT.ADD', 'idx', 'doc999', '1.0', 'REPLACE', 'FIELDS', 'title',
'foo1').ok()
env.cmd('ft.debug', 'GC_FORCEINVOKE', 'idx')
debug_rep = env.cmd('FT.DEBUG', 'DUMP_INVIDX', 'idx', 'foo')
env.assertEqual(len(debug_rep), 0)
# retry with replace partial
debug_rep = env.cmd('FT.DEBUG', 'DUMP_INVIDX', 'idx', 'foo')
for i in range(999):
env.expect('FT.ADD', 'idx', 'doc%d' % i, '1.0', 'REPLACE', 'PARTIAL',
'FIELDS', 'title', 'foo2').ok()
env.cmd('ft.debug', 'GC_FORCEINVOKE', 'idx')
env.expect('FT.DEBUG', 'DUMP_INVIDX', 'idx', 'foo').equal(debug_rep)
env.expect('FT.ADD', 'idx', 'doc999', '1.0', 'REPLACE', 'PARTIAL',
'FIELDS', 'title', 'foo1').ok()
env.cmd('ft.debug', 'GC_FORCEINVOKE', 'idx')
debug_rep = env.cmd('FT.DEBUG', 'DUMP_INVIDX', 'idx', 'foo')
env.assertEqual(len(debug_rep), 0)
def __init__(self):
self.env = Env(decodeResponses=True)
global redis_graph
global redis_con
redis_con = self.env.getConnection()
redis_graph = Graph("graph", redis_con)
class testGraphBulkInsertFlow(FlowTestsBase):
def __init__(self):
self.env = Env(decodeResponses=True)
global redis_graph
global redis_con
redis_con = self.env.getConnection()
redis_graph = Graph("graph", redis_con)
# Run bulk loader script and validate terminal output
def test01_run_script(self):
graphname = "graph"
runner = CliRunner()
csv_path = os.path.dirname(os.path.abspath(__file__)) + '/../../demo/social/resources/bulk_formatted/'
res = runner.invoke(bulk_insert, ['--port', port,
'--nodes', csv_path + 'Person.csv',
'--nodes', csv_path + 'Country.csv',
'--relations', csv_path + 'KNOWS.csv',
'--relations', csv_path + 'VISITED.csv',
graphname])
# The script should report 27 node creations and 48 edge creations
self.env.assertEquals(res.exit_code, 0)
self.env.assertIn('27 nodes created', res.output)
self.env.assertIn('56 relations created', res.output)
# Validate that the expected nodes and properties have been constructed
def test02_validate_nodes(self):
global redis_graph
# Query the newly-created graph
query_result = redis_graph.query('MATCH (p:Person) RETURN p.name, p.age, p.gender, p.status, ID(p) ORDER BY p.name')
# Verify that the Person label exists, has the correct attributes, and is properly populated
expected_result = [['Ailon Velger', 32, 'male', 'married', 2],
['Alon Fital', 32, 'male', 'married', 1],
['Boaz Arad', 31, 'male', 'married', 4],
['Gal Derriere', 26, 'male', 'single', 11],
['Jane Chernomorin', 31, 'female', 'married', 8],
['Lucy Yanfital', 30, 'female', 'married', 7],
['Mor Yesharim', 31, 'female', 'married', 12],
['Noam Nativ', 34, 'male', 'single', 13],
['Omri Traub', 33, 'male', 'single', 5],
['Ori Laslo', 32, 'male', 'married', 3],
['Roi Lipman', 32, 'male', 'married', 0],
['Shelly Laslo Rooz', 31, 'female', 'married', 9],
['Tal Doron', 32, 'male', 'single', 6],
['Valerie Abigail Arad', 31, 'female', 'married', 10]]
self.env.assertEquals(query_result.result_set, expected_result)
# Verify that the Country label exists, has the correct attributes, and is properly populated
query_result = redis_graph.query('MATCH (c:Country) RETURN c.name, ID(c) ORDER BY c.name')
expected_result = [['Andora', 21],
['Canada', 18],
['China', 19],
['Germany', 24],
['Greece', 17],
['Italy', 25],
['Japan', 16],
['Kazakhstan', 22],
['Netherlands', 20],
['Prague', 15],
['Russia', 23],
['Thailand', 26],
['USA', 14]]
self.env.assertEquals(query_result.result_set, expected_result)
# Validate that the expected relations and properties have been constructed
def test03_validate_relations(self):
# Query the newly-created graph
query_result = redis_graph.query('MATCH (a)-[e:KNOWS]->(b) RETURN a.name, e.relation, b.name ORDER BY e.relation, a.name, b.name')
expected_result = [['Ailon Velger', 'friend', 'Noam Nativ'],
['Alon Fital', 'friend', 'Gal Derriere'],
['Alon Fital', 'friend', 'Mor Yesharim'],
['Boaz Arad', 'friend', 'Valerie Abigail Arad'],
['Roi Lipman', 'friend', 'Ailon Velger'],
['Roi Lipman', 'friend', 'Alon Fital'],
['Roi Lipman', 'friend', 'Boaz Arad'],
['Roi Lipman', 'friend', 'Omri Traub'],
['Roi Lipman', 'friend', 'Ori Laslo'],
['Roi Lipman', 'friend', 'Tal Doron'],
['Ailon Velger', 'married', 'Jane Chernomorin'],
['Alon Fital', 'married', 'Lucy Yanfital'],
['Ori Laslo', 'married', 'Shelly Laslo Rooz']]
self.env.assertEquals(query_result.result_set, expected_result)
query_result = redis_graph.query('MATCH (a)-[e:VISITED]->(b) RETURN a.name, e.purpose, b.name ORDER BY e.purpose, a.name, b.name')
expected_result = [['Alon Fital', 'business', 'Prague'],
['Alon Fital', 'business', 'USA'],
['Boaz Arad', 'business', 'Netherlands'],
['Boaz Arad', 'business', 'USA'],
['Gal Derriere', 'business', 'Netherlands'],
['Jane Chernomorin', 'business', 'USA'],
['Lucy Yanfital', 'business', 'USA'],
['Mor Yesharim', 'business', 'Germany'],
['Ori Laslo', 'business', 'China'],
['Ori Laslo', 'business', 'USA'],
['Roi Lipman', 'business', 'Prague'],
['Roi Lipman', 'business', 'USA'],
['Tal Doron', 'business', 'Japan'],
['Tal Doron', 'business', 'USA'],
['Alon Fital', 'pleasure', 'Greece'],
['Alon Fital', 'pleasure', 'Prague'],
['Alon Fital', 'pleasure', 'USA'],
['Boaz Arad', 'pleasure', 'Netherlands'],
['Boaz Arad', 'pleasure', 'USA'],
['Jane Chernomorin', 'pleasure', 'Greece'],
['Jane Chernomorin', 'pleasure', 'Netherlands'],
['Jane Chernomorin', 'pleasure', 'USA'],
['Lucy Yanfital', 'pleasure', 'Kazakhstan'],
['Lucy Yanfital', 'pleasure', 'Prague'],
['Lucy Yanfital', 'pleasure', 'USA'],
['Mor Yesharim', 'pleasure', 'Greece'],
['Mor Yesharim', 'pleasure', 'Italy'],
['Noam Nativ', 'pleasure', 'Germany'],
['Noam Nativ', 'pleasure', 'Netherlands'],
['Noam Nativ', 'pleasure', 'Thailand'],
['Omri Traub', 'pleasure', 'Andora'],
['Omri Traub', 'pleasure', 'Greece'],
['Omri Traub', 'pleasure', 'USA'],
['Ori Laslo', 'pleasure', 'Canada'],
['Roi Lipman', 'pleasure', 'Japan'],
['Roi Lipman', 'pleasure', 'Prague'],
['Shelly Laslo Rooz', 'pleasure', 'Canada'],
['Shelly Laslo Rooz', 'pleasure', 'China'],
['Shelly Laslo Rooz', 'pleasure', 'USA'],
['Tal Doron', 'pleasure', 'Andora'],
['Tal Doron', 'pleasure', 'USA'],
['Valerie Abigail Arad', 'pleasure', 'Netherlands'],
['Valerie Abigail Arad', 'pleasure', 'Russia']]
self.env.assertEquals(query_result.result_set, expected_result)
def test04_private_identifiers(self):
graphname = "tmpgraph1"
# Write temporary files
with open('/tmp/nodes.tmp', mode='w') as csv_file:
out = csv.writer(csv_file)
out.writerow(["_identifier", "nodename"])
out.writerow([0, "a"])
out.writerow([5, "b"])
out.writerow([3, "c"])
with open('/tmp/relations.tmp', mode='w') as csv_file:
out = csv.writer(csv_file)
out.writerow(["src", "dest"])
out.writerow([0, 3])
out.writerow([5, 3])
runner = CliRunner()
res = runner.invoke(bulk_insert, ['--port', port,
'--nodes', '/tmp/nodes.tmp',
'--relations', '/tmp/relations.tmp',
graphname])
# The script should report 3 node creations and 2 edge creations
self.env.assertEquals(res.exit_code, 0)
self.env.assertIn('3 nodes created', res.output)
self.env.assertIn('2 relations created', res.output)
# Delete temporary files
os.remove('/tmp/nodes.tmp')
os.remove('/tmp/relations.tmp')
tmp_graph = Graph(graphname, redis_con)
# The field "_identifier" should not be a property in the graph
query_result = tmp_graph.query('MATCH (a) RETURN a')
for propname in query_result.header:
self.env.assertNotIn('_identifier', propname)
def test05_reused_identifier(self):
graphname = "tmpgraph2"
# Write temporary files
with open('/tmp/nodes.tmp', mode='w') as csv_file:
out = csv.writer(csv_file)
out.writerow(["_identifier", "nodename"])
out.writerow([0, "a"])
out.writerow([5, "b"])
out.writerow([0, "c"]) # reused identifier
with open('/tmp/relations.tmp', mode='w') as csv_file:
out = csv.writer(csv_file)
out.writerow(["src", "dest"])
out.writerow([0, 3])
runner = CliRunner()
res = runner.invoke(bulk_insert, ['--port', port,
'--nodes', '/tmp/nodes.tmp',
'--relations', '/tmp/relations.tmp',
graphname])
# The script should fail because a node identifier is reused
self.env.assertNotEqual(res.exit_code, 0)
self.env.assertIn('used multiple times', res.output)
# Run the script again without creating relations
runner = CliRunner()
res = runner.invoke(bulk_insert, ['--port', port,
'--nodes', '/tmp/nodes.tmp',
graphname])
# The script should succeed and create 3 nodes
self.env.assertEquals(res.exit_code, 0)
self.env.assertIn('3 nodes created', res.output)
# Delete temporary files
os.remove('/tmp/nodes.tmp')
os.remove('/tmp/relations.tmp')
def test06_batched_build(self):
# Create demo graph wth one query per input file
graphname = "batched_graph"
runner = CliRunner()
csv_path = os.path.dirname(os.path.abspath(__file__)) + '/../../demo/social/resources/bulk_formatted/'
res = runner.invoke(bulk_insert, ['--port', port,
'--nodes', csv_path + 'Person.csv',
'--nodes', csv_path + 'Country.csv',
'--relations', csv_path + 'KNOWS.csv',
'--relations', csv_path + 'VISITED.csv',
'--max-token-count', 1,
graphname])
self.env.assertEquals(res.exit_code, 0)
# The script should report statistics multiple times
self.env.assertGreater(res.output.count('nodes created'), 1)
new_graph = Graph(graphname, redis_con)
# Newly-created graph should be identical to graph created in single query
original_result = redis_graph.query('MATCH (p:Person) RETURN p, ID(p) ORDER BY p.name')
new_result = new_graph.query('MATCH (p:Person) RETURN p, ID(p) ORDER BY p.name')
self.env.assertEquals(original_result.result_set, new_result.result_set)
original_result = redis_graph.query('MATCH (a)-[e:KNOWS]->(b) RETURN a.name, e, b.name ORDER BY e.relation, a.name')
new_result = new_graph.query('MATCH (a)-[e:KNOWS]->(b) RETURN a.name, e, b.name ORDER BY e.relation, a.name')
self.env.assertEquals(original_result.result_set, new_result.result_set)
def test07_script_failures(self):
graphname = "tmpgraph3"
# Write temporary files
with open('/tmp/nodes.tmp', mode='w') as csv_file:
out = csv.writer(csv_file)
out.writerow(["id", "nodename"])
out.writerow([0]) # Wrong number of properites
runner = CliRunner()
res = runner.invoke(bulk_insert, ['--port', port,
'--nodes', '/tmp/nodes.tmp',
graphname])
# The script should fail because a row has the wrong number of fields
self.env.assertNotEqual(res.exit_code, 0)
self.env.assertIn('Expected 2 columns', str(res.exception))
# Write temporary files
with open('/tmp/nodes.tmp', mode='w') as csv_file:
out = csv.writer(csv_file)
out.writerow(["id", "nodename"])
out.writerow([0, "a"])
with open('/tmp/relations.tmp', mode='w') as csv_file:
out = csv.writer(csv_file)
out.writerow(["src"]) # Incomplete relation description
out.writerow([0])
runner = CliRunner()
res = runner.invoke(bulk_insert, ['--port', port,
'--nodes', '/tmp/nodes.tmp',
'--relations', '/tmp/relations.tmp',
graphname])
# The script should fail because a row has the wrong number of fields
self.env.assertNotEqual(res.exit_code, 0)
self.env.assertIn('should have at least 2 elements', str(res.exception))
with open('/tmp/relations.tmp', mode='w') as csv_file:
out = csv.writer(csv_file)
out.writerow(["src", "dest"])
out.writerow([0, "fakeidentifier"])
runner = CliRunner()
res = runner.invoke(bulk_insert, ['--port', port,
'--nodes', '/tmp/nodes.tmp',
'--relations', '/tmp/relations.tmp',
graphname])
# The script should fail because an invalid node identifier was used
self.env.assertNotEqual(res.exit_code, 0)
self.env.assertIn('fakeidentifier', str(res.exception))
os.remove('/tmp/nodes.tmp')
os.remove('/tmp/relations.tmp')
# Test passing invalid arguments directly to the GRAPH.BULK endpoint
try:
redis_con.execute_command("GRAPH.BULK", "a", "a", "a")
self.env.assertTrue(False)
except redis.exceptions.ResponseError as e:
self.env.assertIn("Invalid graph operation on empty key", str(e))
# Verify that numeric, boolean, and null types are properly handled
def test08_property_types(self):
graphname = "tmpgraph4"
# Write temporary files
with open('/tmp/nodes.tmp', mode='w') as csv_file:
out = csv.writer(csv_file)
out.writerow(["numeric", "mixed", "bool"])
out.writerow([0, '', True])
out.writerow([5, "notnull", False])
out.writerow([7, '', False]) # reused identifier
with open('/tmp/relations.tmp', mode='w') as csv_file:
out = csv.writer(csv_file)
out.writerow(["src", "dest", "prop"])
out.writerow([0, 5, True])
out.writerow([5, 7, 3.5])
out.writerow([7, 0, ''])
runner = CliRunner()
res = runner.invoke(bulk_insert, ['--port', port,
'--nodes', '/tmp/nodes.tmp',
'--relations', '/tmp/relations.tmp',
graphname])
self.env.assertEquals(res.exit_code, 0)
self.env.assertIn('3 nodes created', res.output)
self.env.assertIn('3 relations created', res.output)
graph = Graph(graphname, redis_con)
query_result = graph.query('MATCH (a)-[e]->() RETURN a.numeric, a.mixed, a.bool, e.prop ORDER BY a.numeric, e.prop')
expected_result = [[0, None, True, True],
[5, 'notnull', False, 3.5],
[7, None, False, None]]
# The graph should have the correct types for all properties
self.env.assertEquals(query_result.result_set, expected_result)
# Verify that the bulk loader does not block the server
def test09_large_bulk_insert(self):
# Skip this test if running under Valgrind, (too slow)
if Env().envRunner.debugger is not None:
Env().skip()
graphname = "tmpgraph5"
prop_str = "Property value to be repeated 1 million generating a multi-megabyte CSV"
# Write temporary files
filename = '/tmp/nodes.tmp'
with open(filename, mode='w') as csv_file:
out = csv.writer(csv_file)
out.writerow(["long_property_string"])
for i in range(100_000):
out.writerow([prop_str])
# Instantiate a thread to run the bulk loader
thread = threading.Thread(target=run_bulk_loader, args=(graphname, filename))
thread.start()
# Ping server while bulk-loader is running
ping_count = 0
while thread.is_alive():
t0 = time.time()
redis_con.ping()
t1 = time.time() - t0
# Verify that pinging the server takes less than 1 second during bulk insertion
self.env.assertLess(t1, 2)
ping_count += 1
thread.join()
# Verify that at least one ping was issued
self.env.assertGreater(ping_count, 1)
def testSpellCheckBadFormat():
env = Env()
env.cmd('ft.dictadd', 'dict', 'name')
env.cmd('ft.create', 'idx', 'SCHEMA', 'name', 'TEXT', 'body', 'TEXT')
env.cmd('ft.add', 'idx', 'doc1', 1.0, 'FIELDS', 'name', 'name1', 'body', 'body1')
env.cmd('ft.add', 'idx', 'doc2', 1.0, 'FIELDS', 'name', 'name2', 'body', 'body2')
env.cmd('ft.add', 'idx', 'doc3', 1.0, 'FIELDS', 'name', 'name2', 'body', 'name2')
env.expect('ft.spellcheck', 'idx', 'name', 'TERMS').raiseError()
env.expect('ft.spellcheck', 'idx', 'name', 'TERMS', 'INCLUDE').raiseError()
env.expect('ft.spellcheck', 'idx', 'name', 'TERMS', 'EXCLUDE').raiseError()
env.expect('ft.spellcheck', 'idx', 'name', 'DISTANCE').raiseError()
env.expect('ft.spellcheck', 'idx', 'name', 'DISTANCE', 0).raiseError()
env.expect('ft.spellcheck', 'idx', 'name', 'DISTANCE', -1).raiseError()
env.expect('ft.spellcheck', 'idx', 'name', 'DISTANCE', 101).raiseError()
def testDictDump():
env = Env()
env.expect('ft.dictadd', 'dict', 'term1', 'term2', 'term3').equal(3)
env.expect('ft.dictdump', 'dict').equal(['term1', 'term2', 'term3'])
def __init__(self):
self.env = Env()
add_values(self.env, 2)
def testDocIndexedInTwoIndexes():
env = Env(moduleArgs='MAXDOCTABLESIZE 50')
env.skipOnCluster()
env.expect('FT.CREATE idx1 SCHEMA t TEXT').ok()
env.expect('FT.CREATE idx2 SCHEMA t TEXT').ok()
for i in range(1000):
env.expect('HSET', 'doc%d' % i, 't', 'foo').equal(1L)
env.expect('FT.DROPINDEX idx2 DD').ok()
env.expect('FT.SEARCH idx1 foo').equal([0L])
env.expect('FT.DROPINDEX idx1 DD').ok()
def testDictDeleteOnNoneExistingKey():
env = Env()
env.expect('ft.dictdel', 'dict', 'term1').equal(0)
def test_keyspace_rules_send():
Env().skipOnCluster()
Env().skipOnVersionSmaller("6.2.0")
skip_on_rlec()
sample_len = 1024
env = Env()
with env.getClusterConnectionIfNeeded() as r:
r.execute_command('config', 'set', 'notify-keyspace-events', 'KEA')
pubsub = r.pubsub()
pubsub.psubscribe('__key*')
time.sleep(1)
env.assertEqual('psubscribe', pubsub.get_message(timeout=1)['type'])
r.execute_command('TS.CREATE', 'tester_src{2}')
assert_msg(env, pubsub.get_message(timeout=1), 'pmessage',
b'ts.create')
assert_msg(env, pubsub.get_message(timeout=1), 'pmessage',
b'tester_src{2}')
r.execute_command('TS.CREATE', 'tester_dest{2}')
assert_msg(env, pubsub.get_message(timeout=1), 'pmessage',
b'ts.create')
assert_msg(env, pubsub.get_message(timeout=1), 'pmessage',
b'tester_dest{2}')
r.execute_command('TS.CREATERULE', 'tester_src{2}', 'tester_dest{2}',
'AGGREGATION', 'MAX', 1)
assert_msg(env, pubsub.get_message(timeout=1), 'pmessage',
b'ts.createrule:src')
assert_msg(env, pubsub.get_message(timeout=1), 'pmessage',
b'tester_src{2}')
assert_msg(env, pubsub.get_message(timeout=1), 'pmessage',
b'ts.createrule:dest')
assert_msg(env, pubsub.get_message(timeout=1), 'pmessage',
b'tester_dest{2}')
r.execute_command('ts.add', 'tester_src{2}', 100, 1.1)
assert_msg(env, pubsub.get_message(timeout=1), 'pmessage', b'ts.add')
assert_msg(env, pubsub.get_message(timeout=1), 'pmessage',
b'tester_src{2}')
for i in range(1000):
r.execute_command('ts.add', 'tester_src{2}', 101 + i, 1.1)
# First getting the event from the dest on the previous window
assert_msg(env, pubsub.get_message(timeout=1), 'pmessage',
b'ts.add:dest')
assert_msg(env, pubsub.get_message(timeout=1), 'pmessage',
b'tester_dest{2}')
assert_msg(env, pubsub.get_message(timeout=1), 'pmessage',
b'ts.add')
assert_msg(env, pubsub.get_message(timeout=1), 'pmessage',
b'tester_src{2}')
r.execute_command('ts.incrby', 'tester_src{2}', 3)
assert_msg(env, pubsub.get_message(timeout=1), 'pmessage',
b'ts.add:dest')
assert_msg(env, pubsub.get_message(timeout=1), 'pmessage',
b'tester_dest{2}')
assert_msg(env, pubsub.get_message(timeout=1), 'pmessage',
b'ts.incrby')
assert_msg(env, pubsub.get_message(timeout=1), 'pmessage',
b'tester_src{2}')
def testDictDumpOnNoneExistingKey():
env = Env()
env.expect('ft.dictdump', 'dict').raiseError()
def test_create_compaction_rule_own():
with Env().getClusterConnectionIfNeeded() as r:
assert r.execute_command('TS.CREATE', key_name)
with pytest.raises(redis.ResponseError) as excinfo:
assert r.execute_command('TS.CREATERULE', key_name, key_name,
'AGGREGATION', 'MAX', 10)
def testDictAddWrongArity():
env = Env()
env.expect('ft.dictadd', 'dict').raiseError()
class testOptionalFlow(FlowTestsBase):
def __init__(self):
self.env = Env()
global redis_graph
redis_con = self.env.getConnection()
redis_graph = Graph("optional_match", redis_con)
self.populate_graph()
def populate_graph(self):
global nodes
# Construct a graph with the form:
# (v1)-[:E1]->(v2)-[:E2]->(v3), (v4)
node_props = ['v1', 'v2', 'v3', 'v4']
for idx, v in enumerate(node_props):
node = Node(label="L", properties={"v": v})
nodes[v] = node
redis_graph.add_node(node)
edge = Edge(nodes['v1'], "E1", nodes['v2'])
redis_graph.add_edge(edge)
edge = Edge(nodes['v2'], "E2", nodes['v3'])
redis_graph.add_edge(edge)
redis_graph.flush()
# Optional MATCH clause that does not interact with the mandatory MATCH.
def test01_disjoint_optional(self):
global redis_graph
query = """MATCH (a {v: 'v1'}) OPTIONAL MATCH (b) RETURN a.v, b.v ORDER BY a.v, b.v"""
actual_result = redis_graph.query(query)
expected_result = [['v1', 'v1'],
['v1', 'v2'],
['v1', 'v3'],
['v1', 'v4']]
self.env.assertEquals(actual_result.result_set, expected_result)
# Optional MATCH clause that extends the mandatory MATCH pattern and has matches for all results.
def test02_optional_traverse(self):
global redis_graph
query = """MATCH (a) WHERE a.v IN ['v1', 'v2'] OPTIONAL MATCH (a)-[]->(b) RETURN a.v, b.v ORDER BY a.v, b.v"""
actual_result = redis_graph.query(query)
expected_result = [['v1', 'v2'],
['v2', 'v3']]
self.env.assertEquals(actual_result.result_set, expected_result)
# Optional MATCH clause that extends the mandatory MATCH pattern and has null results.
def test03_optional_traverse_with_nulls(self):
global redis_graph
query = """MATCH (a) OPTIONAL MATCH (a)-[]->(b) RETURN a.v, b.v ORDER BY a.v, b.v"""
actual_result = redis_graph.query(query)
# (v3) and (v4) have no outgoing edges.
expected_result = [['v1', 'v2'],
['v2', 'v3'],
['v3', None],
['v4', None]]
self.env.assertEquals(actual_result.result_set, expected_result)
# Optional MATCH clause that extends the mandatory MATCH pattern and has a WHERE clause.
def test04_optional_traverse_with_predicate(self):
global redis_graph
query = """MATCH (a) OPTIONAL MATCH (a)-[]->(b) WHERE b.v = 'v2' RETURN a.v, b.v ORDER BY a.v, b.v"""
actual_result = redis_graph.query(query)
# only (v1) has an outgoing edge to (v2).
expected_result = [['v1', 'v2'],
['v2', None],
['v3', None],
['v4', None]]
self.env.assertEquals(actual_result.result_set, expected_result)
# Optional MATCH clause with endpoints resolved by the mandatory MATCH pattern.
def test05_optional_expand_into(self):
global redis_graph
query = """MATCH (a)-[]->(b) OPTIONAL MATCH (a)-[e]->(b) RETURN a.v, b.v, TYPE(e) ORDER BY a.v, b.v"""
actual_result = redis_graph.query(query)
expected_result = [['v1', 'v2', 'E1'],
['v2', 'v3', 'E2']]
self.env.assertEquals(actual_result.result_set, expected_result)
# The OPTIONAL MATCH exactly repeats the MATCH, producing identical results.
query_without_optional = """MATCH (a)-[e]->(b) RETURN a.v, b.v, TYPE(e) ORDER BY a.v, b.v"""
result_without_optional = redis_graph.query(query_without_optional)
self.env.assertEquals(actual_result.result_set, result_without_optional.result_set)
# Optional MATCH clause with endpoints resolved by the mandatory MATCH pattern and new filters introduced.
def test06_optional_expand_into_with_reltype(self):
global redis_graph
query = """MATCH (a)-[]->(b) OPTIONAL MATCH (a)-[e:E2]->(b) RETURN a.v, b.v, TYPE(e) ORDER BY a.v, b.v"""
actual_result = redis_graph.query(query)
# Only (v2)-[E2]->(v3) fulfills the constraint of the OPTIONAL MATCH clause.
expected_result = [['v1', 'v2', None],
['v2', 'v3', 'E2']]
self.env.assertEquals(actual_result.result_set, expected_result)
# Optional MATCH clause with endpoints resolved by the mandatory MATCH pattern, but no mandatory traversal.
def test07_optional_expand_into_cartesian_product(self):
global redis_graph
query = """MATCH (a {v: 'v1'}), (b) OPTIONAL MATCH (a)-[e]->(b) RETURN a.v, b.v, TYPE(e) ORDER BY a.v, b.v"""
actual_result = redis_graph.query(query)
# All nodes are represented, but (v1)-[E1]->(v2) is the only matching connection.
expected_result = [['v1', 'v1', None],
['v1', 'v2', 'E1'],
['v1', 'v3', None],
['v1', 'v4', None]]
self.env.assertEquals(actual_result.result_set, expected_result)
# TODO ExpandInto doesn't evaluate bidirectionally properly
# Optional MATCH clause with endpoints resolved by the mandatory MATCH pattern and a bidirectional optional pattern.
# def test08_optional_expand_into_bidirectional(self):
# global redis_graph
# query = """MATCH (a), (b {v: 'v2'}) OPTIONAL MATCH (a)-[e]-(b) RETURN a.v, b.v, TYPE(e) ORDER BY a.v, b.v"""
# actual_result = redis_graph.query(query)
# # All nodes are represented, but only edges with (v2) as an endpoint match.
# expected_result = [['v1', 'v2', 'E1'],
# ['v2', 'v2', None],
# ['v3', 'v2', 'E2'],
# ['v3', 'v2', None]]
# self.env.assertEquals(actual_result.result_set, expected_result)
# Optional MATCH clause with variable-length traversal and some results match.
def test09_optional_variable_length(self):
global redis_graph
query = """MATCH (a) OPTIONAL MATCH (a)-[*]->(b) RETURN a.v, b.v ORDER BY a.v, b.v"""
actual_result = redis_graph.query(query)
expected_result = [['v1', 'v2'],
['v1', 'v3'],
['v2', 'v3'],
['v3', None],
['v4', None]]
self.env.assertEquals(actual_result.result_set, expected_result)
# Optional MATCH clause with variable-length traversal and all results match.
def test10_optional_variable_length_all_matches(self):
global redis_graph
query = """MATCH (a {v: 'v1'}) OPTIONAL MATCH (a)-[*]->(b) RETURN a.v, b.v ORDER BY a.v, b.v"""
actual_result = redis_graph.query(query)
expected_result = [['v1', 'v2'],
['v1', 'v3']]
self.env.assertEquals(actual_result.result_set, expected_result)
# Optional MATCH clause with a variable-length traversal that has no matches.
def test11_optional_variable_length_no_matches(self):
global redis_graph
query = """MATCH (a {v: 'v3'}) OPTIONAL MATCH (a)-[*]->(b) RETURN a.v, b.v ORDER BY a.v, b.v"""
actual_result = redis_graph.query(query)
expected_result = [['v3', None]]
self.env.assertEquals(actual_result.result_set, expected_result)
# Multiple interdependent optional MATCH clauses.
def test12_multiple_optional_traversals(self):
global redis_graph
query = """MATCH (a) OPTIONAL MATCH (a)-[]->(b) OPTIONAL MATCH (b)-[]->(c) RETURN a.v, b.v, c.v ORDER BY a.v, b.v, c.v"""
actual_result = redis_graph.query(query)
expected_result = [['v1', 'v2', 'v3'],
['v2', 'v3', None],
['v3', None, None],
['v4', None, None]]
self.env.assertEquals(actual_result.result_set, expected_result)
# Multiple interdependent optional MATCH clauses with both directed and bidirectional traversals.
def test13_multiple_optional_multi_directional_traversals(self):
global redis_graph
query = """MATCH (a) OPTIONAL MATCH (a)-[]-(b) OPTIONAL MATCH (b)-[]->(c) RETURN a.v, b.v, c.v ORDER BY a.v, b.v, c.v"""
actual_result = redis_graph.query(query)
expected_result = [['v1', 'v2', 'v3'],
['v2', 'v1', 'v2'],
['v2', 'v3', None],
['v3', 'v2', 'v3'],
['v4', None, None]]
self.env.assertEquals(actual_result.result_set, expected_result)
# Multiple interdependent optional MATCH clauses with exclusively bidirectional traversals.
def test14_multiple_optional_bidirectional_traversals(self):
global redis_graph
query = """MATCH (a) OPTIONAL MATCH (a)-[]-(b) OPTIONAL MATCH (b)-[]-(c) RETURN a.v, b.v, c.v ORDER BY a.v, b.v, c.v"""
actual_result = redis_graph.query(query)
expected_result = [['v1', 'v2', 'v1'],
['v1', 'v2', 'v3'],
['v2', 'v1', 'v2'],
['v2', 'v3', 'v2'],
['v3', 'v2', 'v1'],
['v3', 'v2', 'v3'],
['v4', None, None]]
self.env.assertEquals(actual_result.result_set, expected_result)
# Build a named path in an optional clause.
def test15_optional_named_path(self):
global redis_graph
query = """MATCH (a) OPTIONAL MATCH p = (a)-[]->(b) RETURN length(p) ORDER BY length(p)"""
actual_result = redis_graph.query(query)
# 2 nodes have outgoing edges and 2 do not, so expected 2 paths of length 1 and 2 null results.
expected_result = [[1],
[1],
[None],
[None]]
self.env.assertEquals(actual_result.result_set, expected_result)
# Return a result set with null values in the first record and non-null values in subsequent records.
def test16_optional_null_first_result(self):
global redis_graph
query = """MATCH (a) OPTIONAL MATCH (a)-[e]->(b) RETURN a, b, TYPE(e) ORDER BY EXISTS(b), a.v, b.v"""
actual_result = redis_graph.query(query)
expected_result = [[nodes['v3'], None, None],
[nodes['v4'], None, None],
[nodes['v1'], nodes['v2'], 'E1'],
[nodes['v2'], nodes['v3'], 'E2']]
self.env.assertEquals(actual_result.result_set, expected_result)
def test17_optional_label_introductions(self):
global redis_graph
query = """MATCH (a) OPTIONAL MATCH (a:L)-[]->(b:L) RETURN a.v, b.v ORDER BY a.v, b.v"""
actual_result = redis_graph.query(query)
expected_result = [['v1', 'v2'],
['v2', 'v3'],
['v3', None],
['v4', None]]
self.env.assertEquals(actual_result.result_set, expected_result)
def testRewriteAofSortables():
env = Env(useAof=True)
env.cmd('FT.CREATE', 'idx', 'schema', 'field1', 'TEXT',
'SORTABLE', 'num1', 'NUMERIC', 'SORTABLE')
env.cmd('FT.ADD', 'idx', 'doc', 1.0,
'FIELDS', 'field1', 'Hello World')
env.restart_and_reload()
env.broadcast('SAVE')
# Load some documents
for x in xrange(100):
env.cmd('FT.ADD', 'idx', 'doc{}'.format(x), 1.0, 'FIELDS',
'field1', 'txt{}'.format(random.random()),
'num1', random.random())
for sspec in [('field1', 'asc'), ('num1', 'desc')]:
cmd = ['FT.SEARCH', 'idx', 'txt', 'SORTBY', sspec[0], sspec[1]]
res = env.cmd(*cmd)
env.restart_and_reload()
res2 = env.cmd(*cmd)
env.assertEqual(res, res2)
class testGraphCreationFlow(FlowTestsBase):
def __init__(self):
self.env = Env()
global redis_graph
redis_con = self.env.getConnection()
redis_graph = Graph(GRAPH_ID, redis_con)
def test01_create_return(self):
query = """CREATE (a:person {name:'A'}), (b:person {name:'B'})"""
result = redis_graph.query(query)
self.env.assertEquals(result.nodes_created, 2)
query = """MATCH (src:person) CREATE (src)-[e:knows]->(dest {name:'C'}) RETURN src,e,dest ORDER BY ID(src) DESC LIMIT 1"""
result = redis_graph.query(query)
self.env.assertEquals(result.nodes_created, 2)
self.env.assertEquals(result.relationships_created, 2)
self.env.assertEquals(len(result.result_set), 1)
self.env.assertEquals(result.result_set[0][0].properties['name'], 'B')
def test02_create_from_prop(self):
query = """MATCH (p:person)-[e:knows]->() CREATE (c:clone {doublename: p.name + toLower(p.name), source_of: TYPE(e)}) RETURN c.doublename, c.source_of ORDER BY c.doublename"""
result = redis_graph.query(query)
expected_result = [['Aa', 'knows'], ['Bb', 'knows']]
self.env.assertEquals(result.labels_added, 1)
self.env.assertEquals(result.nodes_created, 2)
self.env.assertEquals(result.properties_set, 4)
self.env.assertEquals(result.result_set, expected_result)
def test03_create_from_projection(self):
query = """UNWIND [10,20,30] AS x CREATE (p:person {age:x}) RETURN p.age ORDER BY p.age"""
result = redis_graph.query(query)
expected_result = [[10], [20], [30]]
self.env.assertEquals(result.nodes_created, 3)
self.env.assertEquals(result.properties_set, 3)
self.env.assertEquals(result.result_set, expected_result)
def test04_create_with_null_properties(self):
query = """CREATE (a:L {v1: NULL, v2: 'prop'}) RETURN a"""
result = redis_graph.query(query)
node = Node(label="L", properties={"v2": "prop"})
expected_result = [[node]]
self.env.assertEquals(result.labels_added, 1)
self.env.assertEquals(result.nodes_created, 1)
self.env.assertEquals(result.properties_set, 1)
self.env.assertEquals(result.result_set, expected_result)
# Create 2 new nodes, one with no properties and one with a property 'v'
query = """CREATE (:M), (:M {v: 1})"""
redis_graph.query(query)
# Verify that a MATCH...CREATE accesses the property correctly.
query = """MATCH (m:M) WITH m ORDER BY m.v DESC CREATE ({v: m.v})"""
result = redis_graph.query(query)
self.env.assertEquals(result.nodes_created, 2)
self.env.assertEquals(result.properties_set, 1)
def __init__(self):
self.env = Env(testName="testing debug commands")
self.env.skipOnCluster()
self.env.expect('FT.CREATE', 'idx', 'SCHEMA', 'name', 'TEXT', 'SORTABLE', 'age', 'NUMERIC', 'SORTABLE', 't', 'TAG', 'SORTABLE').ok()
self.env.expect('FT.ADD', 'idx', 'doc1', '1.0', 'FIELDS', 'name', 'meir', 'age', '29', 't', 'test').ok()
def __init__(self):
self.env = Env()
global redis_graph
redis_con = self.env.getConnection()
redis_graph = Graph(GRAPH_ID, redis_con)
def testAofRewriteSortkeys():
env = Env(useAof=True)
env.cmd('FT.CREATE', 'idx', 'ON', 'HASH', 'SCHEMA', 'foo', 'TEXT',
'SORTABLE', 'bar', 'TAG')
env.cmd('FT.ADD', 'idx', '1', '1', 'FIELDS', 'foo', 'A', 'bar', '1')
env.cmd('FT.ADD', 'idx', '2', '1', 'fields', 'foo', 'B', 'bar', '1')
res_exp = env.cmd('FT.SEARCH', 'idx', '@bar:{1}', 'SORTBY', 'foo', 'ASC',
'RETURN', '1', 'foo', 'WITHSORTKEYS')
env.restart_and_reload()
waitForIndex(env, 'idx')
res_got = env.cmd('FT.SEARCH', 'idx', '@bar:{1}', 'SORTBY', 'foo', 'ASC',
'RETURN', '1', 'foo', 'WITHSORTKEYS')
env.assertEqual(res_exp, res_got)
def __init__(self):
# skip test if we're running under Valgrind
if Env().envRunner.debugger is not None:
Env().skip() # valgrind is not working correctly with replication
self.env = Env(decodeResponses=True, env='oss', useSlaves=True)
def testSpellCheckExcludeDict():
env = Env()
env.cmd('ft.dictadd', 'dict', 'name')
env.cmd('ft.create', 'idx', 'SCHEMA', 'name', 'TEXT', 'body', 'TEXT')
env.cmd('ft.add', 'idx', 'doc1', 1.0, 'FIELDS', 'name', 'name1', 'body', 'body1')
env.cmd('ft.add', 'idx', 'doc2', 1.0, 'FIELDS', 'name', 'name2', 'body', 'body2')
env.cmd('ft.add', 'idx', 'doc3', 1.0, 'FIELDS', 'name', 'name2', 'body', 'name2')
env.expect('ft.spellcheck', 'idx', 'name', 'TERMS', 'EXCLUDE', 'dict').equal([])
env.expect('ft.spellcheck', 'idx', 'name', 'TERMS', 'exclude', 'dict').equal([])
class testQueryValidationFlow(FlowTestsBase):
def __init__(self):
self.env = Env(decodeResponses=True)
global redis_con
global redis_graph
redis_con = self.env.getConnection()
redis_graph = Graph("G", redis_con)
self.populate_graph()
def populate_graph(self):
# Create a single graph.
global redis_graph
node = Node(properties={"age": 34})
redis_graph.add_node(node)
redis_graph.commit()
# Expect an error when trying to use a function which does not exists.
def test01_none_existing_function(self):
query = """MATCH (n) RETURN noneExistingFunc(n.age) AS cast"""
try:
redis_graph.query(query)
self.env.assertTrue(False)
except redis.exceptions.ResponseError:
# Expecting an error.
pass
# Make sure function validation is type case insensitive.
def test02_case_insensitive_function_name(self):
try:
query = """MATCH (n) RETURN mAx(n.age)"""
redis_graph.query(query)
except redis.exceptions.ResponseError:
# function validation should be case insensitive.
self.env.assertTrue(False)
def test03_edge_missing_relation_type(self):
try:
query = """CREATE (n:Person {age:32})-[]->(:person {age:30})"""
redis_graph.query(query)
self.env.assertTrue(False)
except redis.exceptions.ResponseError:
# Expecting an error.
pass
def test04_escaped_quotes(self):
query = r"CREATE (:escaped{prop1:'single \' char', prop2: 'double \" char', prop3: 'mixed \' and \" chars'})"
actual_result = redis_graph.query(query)
self.env.assertEquals(actual_result.nodes_created, 1)
self.env.assertEquals(actual_result.properties_set, 3)
query = r"MATCH (a:escaped) RETURN a.prop1, a.prop2, a.prop3"
actual_result = redis_graph.query(query)
expected_result = [[
"single ' char", 'double " char', 'mixed \' and " chars'
]]
self.env.assertEquals(actual_result.result_set, expected_result)
def test05_invalid_entity_references(self):
try:
query = """MATCH (a) RETURN e"""
redis_graph.query(query)
assert (False)
except redis.exceptions.ResponseError:
# Expecting an error.
pass
try:
query = """MATCH (a) RETURN a ORDER BY e"""
redis_graph.query(query)
assert (False)
except redis.exceptions.ResponseError:
# Expecting an error.
pass
def test06_where_references(self):
try:
query = """MATCH (a) WHERE fake = true RETURN a"""
redis_graph.query(query)
assert (False)
except redis.exceptions.ResponseError:
# Expecting an error.
pass
def test07_with_references(self):
try:
query = """MATCH (a) WITH e RETURN e"""
redis_graph.query(query)
assert (False)
except redis.exceptions.ResponseError:
# Expecting an error.
pass
def test08_count_distinct_star(self):
try:
query = """MATCH (a) RETURN COUNT(DISTINCT *)"""
redis_graph.query(query)
assert (False)
except redis.exceptions.ResponseError:
# Expecting an error.
pass
def test09_invalid_apply_all(self):
try:
query = """MATCH (a) RETURN SUM(*)"""
redis_graph.query(query)
assert (False)
except redis.exceptions.ResponseError:
# Expecting an error.
pass
def test10_missing_params(self):
try:
query = """MATCH (a {name:$name}) RETURN a"""
redis_graph.query(query)
assert (False)
except redis.exceptions.ResponseError:
# Expecting an error.
pass
def test11_param_error(self):
try:
query = """CYPHER name=({name:'a'}) MATCH (a {name:$name}) RETURN a"""
redis_graph.query(query)
assert (False)
except redis.exceptions.ResponseError:
# Expecting an error.
pass
def test12_invalid_query_order(self):
try:
query = """MERGE (a) MATCH (a)-[]->(b) RETURN b"""
redis_graph.query(query)
assert (False)
except redis.exceptions.ResponseError:
# Expecting an error.
pass
def test13_create_bound_variables(self):
try:
query = """MATCH (a)-[e]->(b) CREATE (a)-[e]->(b)"""
redis_graph.query(query)
assert (False)
except redis.exceptions.ResponseError:
# Expecting an error.
pass
def test14_treat_path_as_entity(self):
redis_graph.query("CREATE ()-[:R]->()")
try:
query = """MATCH x=()-[]->() RETURN x.name"""
redis_graph.query(query)
assert (False)
except redis.exceptions.ResponseError:
# Expecting an error.
pass
def test15_dont_crash_on_multiple_errors(self):
try:
query = """MATCH (a) where id(a) IN range(0) OR id(a) in range(1)"""
redis_graph.query(query)
assert (False)
except redis.exceptions.ResponseError:
# Expecting an error.
pass
# Run a query in which a parsed parameter introduces a type in an unsupported context.
def test16_param_introduces_unhandled_type(self):
try:
query = """CYPHER props={a:1,b:2} CREATE (a:A $props)"""
redis_graph.query(query)
assert (False)
except redis.exceptions.ResponseError as e:
# Expecting an error.
assert ("Encountered unhandled type" in str(e))
pass
# Validate that the module fails properly with incorrect argument counts.
def test17_query_arity(self):
# Call GRAPH.QUERY with a missing query argument.
try:
res = redis_con.execute_command("GRAPH.QUERY", "G")
assert (False)
except redis.exceptions.ResponseError as e:
# Expecting an error.
assert ("wrong number of arguments" in str(e))
pass
# Run queries in which compile-time variables are accessed but not defined.
def test18_undefined_variable_access(self):
try:
query = """CREATE (:person{name:bar[1]})"""
redis_graph.query(query)
assert (False)
except redis.exceptions.ResponseError as e:
# Expecting an error.
assert ("not defined" in str(e))
pass
try:
query = """MATCH (a {val: undeclared}) RETURN a"""
redis_graph.query(query)
assert (False)
except redis.exceptions.ResponseError as e:
# Expecting an error.
assert ("not defined" in str(e))
pass
try:
query = """UNWIND [fake] AS ref RETURN ref"""
redis_graph.query(query)
assert (False)
except redis.exceptions.ResponseError as e:
# Expecting an error.
assert ("not defined" in str(e))
pass
def test19_invalid_cypher_options(self):
query = "EXPLAIN MATCH (p:president)-[:born]->(:state {name:'Hawaii'}) RETURN p"
try:
redis_graph.query(query)
assert (False)
except:
# Expecting an error.
pass
query = "PROFILE MATCH (p:president)-[:born]->(:state {name:'Hawaii'}) RETURN p"
try:
redis_graph.query(query)
assert (False)
except:
# Expecting an error.
pass
query = "CYPHER val=1 EXPLAIN MATCH (p:president)-[:born]->(:state {name:'Hawaii'}) RETURN p"
try:
redis_graph.query(query)
assert (False)
except:
# Expecting an error.
pass
query = "CYPHER val=1 PROFILE MATCH (p:president)-[:born]->(:state {name:'Hawaii'}) RETURN p"
try:
redis_graph.query(query)
assert (False)
except:
# Expecting an error.
pass
# Undirected edges are not allowed in CREATE clauses.
def test20_undirected_edge_creation(self):
try:
query = """CREATE (:Endpoint)-[:R]-(:Endpoint)"""
redis_graph.query(query)
assert (False)
except redis.exceptions.ResponseError as e:
# Expecting an error.
assert ("Only directed relationships" in str(e))
pass
# Applying a filter for non existing entity.
def test20_non_existing_graph_entity(self):
try:
query = """MATCH p=() WHERE p.name='value' RETURN p"""
redis_graph.query(query)
assert (False)
except redis.exceptions.ResponseError as e:
# Expecting an error.
assert ("Type mismatch: expected Node but was Path" in str(e))
pass
# Comments should not affect query functionality.
def test21_ignore_query_comments(self):
query = """MATCH (n) // This is a comment
/* This is a block comment */
WHERE EXISTS(n.age)
RETURN n.age /* Also a block comment*/"""
actual_result = redis_graph.query(query)
expected_result = [[34]]
self.env.assertEquals(actual_result.result_set, expected_result)
query = """/* A block comment*/ MATCH (n) // This is a comment
/* This is a block comment */
WHERE EXISTS(n.age)
RETURN n.age /* Also a block comment*/"""
actual_result = redis_graph.query(query)
expected_result = [[34]]
self.env.assertEquals(actual_result.result_set, expected_result)
query = """// This is a comment
MATCH (n) // This is a comment
/* This is a block comment */
WHERE EXISTS(n.age)
RETURN n.age /* Also a block comment*/"""
actual_result = redis_graph.query(query)
expected_result = [[34]]
self.env.assertEquals(actual_result.result_set, expected_result)
query = """MATCH (n) /* This is a block comment */ WHERE EXISTS(n.age)
RETURN n.age /* Also a block comment*/"""
actual_result = redis_graph.query(query)
expected_result = [[34]]
self.env.assertEquals(actual_result.result_set, expected_result)
# Validate procedure call refrences and definitions
def test22_procedure_validations(self):
try:
# procedure call refering to a none existing alias 'n'
query = """CALL db.idx.fulltext.queryNodes(n, 'B') YIELD node RETURN node"""
redis_graph.query(query)
assert (False)
except redis.exceptions.ResponseError as e:
# Expecting an error.
assert ("not defined" in str(e))
pass
# refer to procedure call original output when output is aliased.
try:
query = """CALL db.idx.fulltext.queryNodes('A', 'B') YIELD node AS n RETURN node"""
redis_graph.query(query)
assert (False)
except redis.exceptions.ResponseError as e:
# Expecting an error.
assert ("not defined" in str(e))
pass
# valid procedure call, no output aliasing
query = """CALL db.idx.fulltext.queryNodes('A', 'B') YIELD node RETURN node"""
redis_graph.query(query)
# valid procedure call, output aliasing
query = """CALL db.idx.fulltext.queryNodes('A', 'B') YIELD node AS n RETURN n"""
redis_graph.query(query)
# Applying a filter for a non-boolean constant should raise a compile-time error.
def test23_invalid_constant_filter(self):
try:
query = """MATCH (a) WHERE 1 RETURN a"""
redis_graph.query(query)
assert (False)
except redis.exceptions.ResponseError as e:
assert ("Expected boolean predicate" in str(e))
pass
# Referencing a variable before defining it should raise a compile-time error.
def test24_reference_before_definition(self):
try:
query = """MATCH ({prop: reference}) MATCH (reference) RETURN *"""
redis_graph.query(query)
assert (False)
except redis.exceptions.ResponseError as e:
# Expecting an error.
assert ("not defined" in str(e))
pass
# Invalid filters in cartesian products should raise errors.
def test25_cartesian_product_invalid_filter(self):
try:
query = """MATCH p1=(), (n), ({prop: p1.path_val}) RETURN *"""
redis_graph.query(query)
assert (False)
except redis.exceptions.ResponseError as e:
# Expecting an error.
assert ("Type mismatch: expected Node but was Path" in str(e))
pass
# Scalar predicates in filters should raise errors.
def test26_invalid_filter_predicate(self):
try:
query = """WITH 1 AS a WHERE '' RETURN a"""
redis_graph.query(query)
assert (False)
except redis.exceptions.ResponseError as e:
# Expecting an error.
assert ("Expected boolean predicate" in str(e))
pass
# Conditional filters with non-boolean scalar predicate children should raise errors.
def test27_invalid_filter_predicate_child(self):
try:
# 'Amor' is an invalid construct for the RHS of 'OR'.
query = """MATCH (a:Author) WHERE a.name CONTAINS 'Ernest' OR 'Amor' RETURN a"""
redis_graph.query(query)
assert (False)
except redis.exceptions.ResponseError as e:
# Expecting an error.
assert ("Expected boolean predicate" in str(e))
pass
# The NOT operator does not compare left and right side expressions.
def test28_invalid_filter_binary_not(self):
try:
# Query should have been:
# MATCH (u) where u.v IS NOT NULL RETURN u
query = """MATCH (u) where u.v NOT NULL RETURN u"""
redis_graph.query(query)
assert (False)
except redis.exceptions.ResponseError as e:
# Expecting an error.
assert ("Invalid usage of 'NOT' filter" in str(e))
pass
def test29_invalid_filter_non_boolean_constant(self):
try:
query = """MATCH (a) WHERE a RETURN a"""
redis_graph.query(query)
assert (False)
except redis.exceptions.ResponseError as e:
assert ("expected Boolean but was Node" in str(e))
pass
try:
query = """MATCH (a) WHERE 1+rand() RETURN a"""
redis_graph.query(query)
assert (False)
except redis.exceptions.ResponseError as e:
assert ("expected Boolean but was Float" in str(e))
pass
try:
query = """CYPHER p=3 WITH 1 AS a WHERE $p RETURN a"""
redis_graph.query(query)
assert (False)
except redis.exceptions.ResponseError as e:
assert ("expected Boolean but was Integer" in str(e))
pass
# 'val' is a boolean, so this query is valid.
query = """WITH true AS val WHERE val return val"""
redis_graph.query(query)
# Non-existent properties are treated as NULLs, which are boolean in Cypher's 3-valued logic.
query = """MATCH (a) WHERE a.fakeprop RETURN a"""
redis_graph.query(query)
# Encountering traversals as property values or ORDER BY expressions should raise compile-time errors.
def test30_unexpected_traversals(self):
queries = [
"""MATCH (a {prop: ()-[]->()}) RETURN a""",
"""MATCH (a) RETURN a ORDER BY (a)-[]->()""",
"""MATCH (a) RETURN (a)-[]->()"""
]
for query in queries:
try:
redis_graph.query(query)
assert (False)
except redis.exceptions.ResponseError as e:
# Expecting an error.
assert ("Encountered path traversal" in str(e))
def test31_set_invalid_property_type(self):
queries = [
"""MATCH (a) CREATE (:L {v: a})""",
"""MATCH (a), (b) WHERE b.age IS NOT NULL SET b.age = a""",
"""MERGE (a) ON MATCH SET a.age = a"""
]
for q in queries:
try:
redis_graph.query(q)
assert (False)
except redis.exceptions.ResponseError as e:
# Expecting an error.
assert ("Property values can only be of primitive types"
in str(e))
pass
def test32_return_following_clauses(self):
# After a RETURN clause we're expecting only the following clauses:
# SKIP, LIMIT, ORDER-BY and UNION, given that SKIP and LIMIT are
# actually attributes of the RETURN clause this leaves us with
# ORDER-BY and UNION.
invalid_queries = [
"""RETURN 1 CREATE ()""", """RETURN 1 RETURN 2""",
"""MATCH(n) RETURN n DELETE n""",
"""MATCH(n) RETURN n SET n.v = 1""", """RETURN 1 MERGE ()""",
"""RETURN 1 MATCH (n) RETURN n""",
"""RETURN 1 WITH 1 as one RETURN one"""
]
# Invalid queries, expecting errors.
for q in invalid_queries:
try:
redis_graph.query(q)
assert (False)
except redis.exceptions.ResponseError as e:
# Expecting an error.
assert ("Unexpected clause following RETURN" in str(e))
pass
# Parameters cannot reference aliases.
def test33_alias_reference_in_param(self):
try:
query = """CYPHER A=[a] RETURN 5"""
redis_graph.query(query)
assert (False)
except redis.exceptions.ResponseError as e:
# Expecting an error.
assert ("Attempted to access variable" in str(e))
pass
def test34_self_referential_properties(self):
# Skip this test if running under Valgrind, as it causes a memory leak.
if Env().envRunner.debugger is not None:
Env().skip()
try:
# The server should emit an error on trying to create a node with a self-referential property.
query = """CREATE (a:L {v: a.v})"""
redis_graph.query(query)
assert (False)
except redis.exceptions.ResponseError as e:
# Expecting an error.
self.env.assertIn("undefined property", str(e))
# MATCH clauses should be able to use self-referential properties as existential filters.
query = """MATCH (a {age: a.age}) RETURN a.age"""
actual_result = redis_graph.query(query)
expected_result = [[34]]
self.env.assertEquals(actual_result.result_set, expected_result)
# Test a query that allocates a large buffer.
def test35_large_query(self):
retval = "abcdef" * 1_000
query = "RETURN " + "\"" + retval + "\""
actual_result = redis_graph.query(query)
self.env.assertEquals(actual_result.result_set[0][0], retval)
def testSpellCheckWrongArity():
env = Env()
env.cmd('ft.dictadd', 'dict', 'name')
env.cmd('ft.create', 'idx', 'SCHEMA', 'name', 'TEXT', 'body', 'TEXT')
env.cmd('ft.add', 'idx', 'doc1', 1.0, 'FIELDS', 'name', 'name1', 'body', 'body1')
env.cmd('ft.add', 'idx', 'doc2', 1.0, 'FIELDS', 'name', 'name2', 'body', 'body2')
env.cmd('ft.add', 'idx', 'doc3', 1.0, 'FIELDS', 'name', 'name2', 'body', 'name2')
env.expect('ft.spellcheck', 'idx').raiseError()
env.expect('ft.spellcheck', 'idx').raiseError()
class testPathFilter(FlowTestsBase):
def __init__(self):
self.env = Env()
global redis_con
redis_con = self.env.getConnection()
def setUp(self):
global redis_graph
redis_graph = Graph(GRAPH_ID, redis_con)
self.env.flush()
def test00_simple_path_filter(self):
node0 = Node(node_id=0, label="L")
node1 = Node(node_id=1, label="L", properties={'x': 1})
edge01 = Edge(src_node=node0, dest_node=node1, relation="R")
redis_graph.add_node(node0)
redis_graph.add_node(node1)
redis_graph.add_edge(edge01)
redis_graph.flush()
query = "MATCH (n:L) WHERE (n)-[:R]->(:L) RETURN n"
result_set = redis_graph.query(query)
expected_results = [[node0]]
query_info = QueryInfo(query=query,
description="Tests simple path filter",
expected_result=expected_results)
self._assert_resultset_equals_expected(result_set, query_info)
def test01_negated_simple_path_filter(self):
node0 = Node(node_id=0, label="L")
node1 = Node(node_id=1, label="L", properties={'x': 1})
edge01 = Edge(src_node=node0, dest_node=node1, relation="R")
redis_graph.add_node(node0)
redis_graph.add_node(node1)
redis_graph.add_edge(edge01)
redis_graph.flush()
query = "MATCH (n:L) WHERE NOT (n)-[:R]->(:L) RETURN n"
result_set = redis_graph.query(query)
expected_results = [[node1]]
query_info = QueryInfo(query=query,
description="Tests simple negated path filter",
expected_result=expected_results)
self._assert_resultset_equals_expected(result_set, query_info)
def test02_test_path_filter_or_property_filter(self):
node0 = Node(node_id=0, label="L")
node1 = Node(node_id=1, label="L", properties={'x': 1})
edge01 = Edge(src_node=node0, dest_node=node1, relation="R")
redis_graph.add_node(node0)
redis_graph.add_node(node1)
redis_graph.add_edge(edge01)
redis_graph.flush()
query = "MATCH (n:L) WHERE (n)-[:R]->(:L) OR n.x=1 RETURN n"
result_set = redis_graph.query(query)
expected_results = [[node0], [node1]]
query_info = QueryInfo(
query=query,
description="Tests OR condition with simple filter and path filter",
expected_result=expected_results)
self._assert_resultset_and_expected_mutually_included(
result_set, query_info)
def test03_path_filter_or_negated_path_filter(self):
node0 = Node(node_id=0, label="L")
node1 = Node(node_id=1, label="L", properties={'x': 1})
edge01 = Edge(src_node=node0, dest_node=node1, relation="R")
redis_graph.add_node(node0)
redis_graph.add_node(node1)
redis_graph.add_edge(edge01)
redis_graph.flush()
query = "MATCH (n:L) WHERE (n)-[:R]->(:L) OR NOT (n)-[:R]->(:L) RETURN n"
result_set = redis_graph.query(query)
expected_results = [[node0], [node1]]
query_info = QueryInfo(
query=query,
description="Tests OR condition with path and negated path filters",
expected_result=expected_results)
self._assert_resultset_and_expected_mutually_included(
result_set, query_info)
def test04_test_level_1_nesting_logical_operators_over_path_and_property_filters(
self):
node0 = Node(node_id=0, label="L")
node1 = Node(node_id=1, label="L", properties={'x': 1})
edge01 = Edge(src_node=node0, dest_node=node1, relation="R")
redis_graph.add_node(node0)
redis_graph.add_node(node1)
redis_graph.add_edge(edge01)
redis_graph.flush()
query = "MATCH (n:L) WHERE (n)-[:R]->(:L) OR (n.x=1 AND NOT (n)-[:R]->(:L)) RETURN n"
result_set = redis_graph.query(query)
expected_results = [[node0], [node1]]
query_info = QueryInfo(
query=query,
description=
"Tests AND condition with simple filter and negated path filter",
expected_result=expected_results)
self._assert_resultset_and_expected_mutually_included(
result_set, query_info)
def test05_test_level_2_nesting_logical_operators_over_path_and_property_filters(
self):
node0 = Node(node_id=0, label="L")
node1 = Node(node_id=1, label="L", properties={'x': 1})
edge01 = Edge(src_node=node0, dest_node=node1, relation="R")
redis_graph.add_node(node0)
redis_graph.add_node(node1)
redis_graph.add_edge(edge01)
redis_graph.flush()
query = "MATCH (n:L) WHERE (n)-[:R]->(:L) OR (n.x=1 AND (n.x = 2 OR NOT (n)-[:R]->(:L))) RETURN n"
result_set = redis_graph.query(query)
expected_results = [[node0], [node1]]
query_info = QueryInfo(
query=query,
description="Tests AND condition with simple filter and nested OR",
expected_result=expected_results)
self._assert_resultset_and_expected_mutually_included(
result_set, query_info)
def test06_test_level_2_nesting_logical_operators_over_path_filters(self):
node0 = Node(node_id=0, label="L")
node1 = Node(node_id=1, label="L", properties={'x': 1})
node2 = Node(node_id=2, label="L2")
edge01 = Edge(src_node=node0, dest_node=node1, relation="R")
edge12 = Edge(src_node=node1, dest_node=node2, relation="R2")
redis_graph.add_node(node0)
redis_graph.add_node(node1)
redis_graph.add_node(node2)
redis_graph.add_edge(edge01)
redis_graph.add_edge(edge12)
redis_graph.flush()
query = "MATCH (n:L) WHERE (n)-[:R]->(:L) OR (n.x=1 AND ((n)-[:R2]->(:L2) OR (n)-[:R]->(:L))) RETURN n"
result_set = redis_graph.query(query)
expected_results = [[node0], [node1]]
query_info = QueryInfo(
query=query,
description="Tests AND condition with simple filter and nested OR",
expected_result=expected_results)
self._assert_resultset_and_expected_mutually_included(
result_set, query_info)
def test07_test_edge_filters(self):
node0 = Node(node_id=0, label="L", properties={'x': 'a'})
node1 = Node(node_id=1, label="L", properties={'x': 'b'})
node2 = Node(node_id=2, label="L", properties={'x': 'c'})
edge01 = Edge(src_node=node0,
dest_node=node1,
relation="R",
properties={'x': 1})
edge12 = Edge(src_node=node1, dest_node=node2, relation="R")
redis_graph.add_node(node0)
redis_graph.add_node(node1)
redis_graph.add_node(node2)
redis_graph.add_edge(edge01)
redis_graph.add_edge(edge12)
redis_graph.flush()
query = "MATCH (n:L) WHERE (n)-[:R {x:1}]->() RETURN n.x"
result_set = redis_graph.query(query)
expected_results = [['a']]
query_info = QueryInfo(
query=query,
description="Tests pattern filter edge conditions",
expected_result=expected_results)
self._assert_resultset_and_expected_mutually_included(
result_set, query_info)
def test08_indexed_child_stream_resolution(self):
node0 = Node(node_id=0, label="L", properties={'x': 'a'})
node1 = Node(node_id=1, label="L", properties={'x': 'b'})
node2 = Node(node_id=2, label="L", properties={'x': 'c'})
edge01 = Edge(src_node=node0, dest_node=node1, relation="R")
edge12 = Edge(src_node=node1, dest_node=node2, relation="R")
redis_graph.add_node(node0)
redis_graph.add_node(node1)
redis_graph.add_node(node2)
redis_graph.add_edge(edge01)
redis_graph.add_edge(edge12)
redis_graph.flush()
# Create index.
query = "CREATE INDEX ON :L(x)"
result_set = redis_graph.query(query)
self.env.assertEquals(result_set.indices_created, 1)
# Issue a query in which the bound variable stream of the SemiApply op is an Index Scan.
query = "MATCH (n:L) WHERE (:L)<-[]-(n)<-[]-(:L {x: 'a'}) AND n.x = 'b' RETURN n.x"
result_set = redis_graph.query(query)
expected_results = [['b']]
self.env.assertEquals(result_set.result_set, expected_results)
def test09_no_invalid_expand_into(self):
node0 = Node(node_id=0, label="L", properties={'x': 'a'})
node1 = Node(node_id=1, label="L", properties={'x': 'b'})
node2 = Node(node_id=2, label="L", properties={'x': 'c'})
edge01 = Edge(src_node=node0, dest_node=node1, relation="R")
edge12 = Edge(src_node=node1, dest_node=node2, relation="R")
redis_graph.add_node(node0)
redis_graph.add_node(node1)
redis_graph.add_node(node2)
redis_graph.add_edge(edge01)
redis_graph.add_edge(edge12)
redis_graph.flush()
# Issue a query in which the match stream and the bound stream must both perform traversal.
query = "MATCH (n:L)-[]->(:L) WHERE ({x: 'a'})-[]->(n) RETURN n.x"
plan = redis_graph.execution_plan(query)
# Verify that the execution plan has no Expand Into and two traversals.
self.env.assertNotIn("Expand Into", plan)
self.env.assertEquals(2, plan.count("Conditional Traverse"))
result_set = redis_graph.query(query)
expected_results = [['b']]
self.env.assertEquals(result_set.result_set, expected_results)
def test10_verify_apply_results(self):
# Build a graph with 3 nodes and 3 edges, 2 of which have the same source.
node0 = Node(node_id=0, label="L", properties={'x': 'a'})
node1 = Node(node_id=1, label="L", properties={'x': 'b'})
node2 = Node(node_id=2, label="L", properties={'x': 'c'})
edge01 = Edge(src_node=node0, dest_node=node1, relation="R")
edge02 = Edge(src_node=node0, dest_node=node2, relation="R")
edge12 = Edge(src_node=node1, dest_node=node2, relation="R")
redis_graph.add_node(node0)
redis_graph.add_node(node1)
redis_graph.add_node(node2)
redis_graph.add_edge(edge01)
redis_graph.add_edge(edge02)
redis_graph.add_edge(edge12)
redis_graph.flush()
query = "MATCH (n:L) WHERE (n)-[]->() RETURN n.x ORDER BY n.x"
result_set = redis_graph.query(query)
# Each source node should be returned exactly once.
expected_results = [['a'], ['b']]
self.env.assertEquals(result_set.result_set, expected_results)
def test11_unbound_path_filters(self):
# Build a graph with 2 nodes connected by 1 edge.
node0 = Node(node_id=0, label="L", properties={'x': 'a'})
node1 = Node(node_id=1, label="L", properties={'x': 'b'})
edge01 = Edge(src_node=node0, dest_node=node1, relation="R")
redis_graph.add_node(node0)
redis_graph.add_node(node1)
redis_graph.add_edge(edge01)
redis_graph.flush()
# Emit a query that uses an AntiSemiApply op to return values.
query = "MATCH (n:L) WHERE NOT (:L)-[]->() RETURN n.x ORDER BY n.x"
result_set = redis_graph.query(query)
# The WHERE filter evaluates to false, no results should be returned.
expected_result = []
self.env.assertEquals(result_set.result_set, expected_result)
# Emit a query that uses a SemiApply op to return values.
query = "MATCH (n:L) WHERE (:L)-[]->() RETURN n.x ORDER BY n.x"
result_set = redis_graph.query(query)
# The WHERE filter evaluates to true, all results should be returned.
expected_result = [['a'], ['b']]
self.env.assertEquals(result_set.result_set, expected_result)
def test12_label_introduced_in_path_filter(self):
# Build a graph with 2 nodes connected by 1 edge.
node0 = Node(node_id=0, label="L", properties={'x': 'a'})
node1 = Node(node_id=1, label="L", properties={'x': 'b'})
edge01 = Edge(src_node=node0, dest_node=node1, relation="R")
redis_graph.add_node(node0)
redis_graph.add_node(node1)
redis_graph.add_edge(edge01)
redis_graph.flush()
# Write a WHERE filter that introduces label data.
query = "MATCH (a1)-[]->(a2) WHERE (a1:L)-[]->(a2:L) return a1.x, a2.x"
result_set = redis_graph.query(query)
expected_result = [['a', 'b']]
self.env.assertEquals(result_set.result_set, expected_result)
def test13_path_filter_in_different_scope(self):
# Create a graph of the form:
# (c)-[]->(a)-[]->(b)
node0 = Node(node_id=0, label="L", properties={'x': 'a'})
node1 = Node(node_id=1, label="L", properties={'x': 'b'})
node2 = Node(node_id=2, label="L", properties={'x': 'c'})
edge01 = Edge(src_node=node0, dest_node=node1, relation="R")
edge12 = Edge(src_node=node1, dest_node=node2, relation="R")
redis_graph.add_node(node0)
redis_graph.add_node(node1)
redis_graph.add_node(node2)
redis_graph.add_edge(edge01)
redis_graph.add_edge(edge12)
redis_graph.flush()
# Match nodes with an outgoing edge that optionally have an incoming edge.
query = "MATCH (a) OPTIONAL MATCH (a)<-[]-() WITH a WHERE (a)-[]->() return a.x ORDER BY a.x"
result_set = redis_graph.query(query)
expected_result = [['a'], ['b']]
self.env.assertEquals(result_set.result_set, expected_result)
def testDictDelete():
env = Env()
env.expect('ft.dictadd', 'dict', 'term1', 'term2', 'term3').equal(3)
env.expect('ft.dictdel', 'dict', 'term1', 'term2', 'term4').equal(2)
env.expect('ft.dictdel', 'dict', 'term3').equal(1)
env.expect('keys', '*').equal([])
def __init__(self):
self.env = Env()
global redis_con
redis_con = self.env.getConnection()
def testSpellCheckResultsOrder():
env = Env()
env.cmd('ft.dictadd', 'dict', 'name')
env.cmd('ft.create', 'idx', 'SCHEMA', 'name', 'TEXT', 'body', 'TEXT')
env.cmd('ft.add', 'idx', 'doc1', 1.0, 'FIELDS', 'name', 'Elior', 'body', 'body1')
env.cmd('ft.add', 'idx', 'doc2', 1.0, 'FIELDS', 'name', 'Hila', 'body', 'body2')
env.expect('ft.spellcheck', 'idx', 'Elioh Hilh').equal([['TERM', 'elioh', [['0.5', 'elior']]], ['TERM', 'hilh', [['0.5', 'hila']]]])
class testFunctionCallsFlow(FlowTestsBase):
def __init__(self):
self.env = Env(decodeResponses=True)
global graph
global redis_con
redis_con = self.env.getConnection()
graph = Graph("G", redis_con)
self.populate_graph()
def populate_graph(self):
global graph
nodes = {}
# Create entities
for idx, p in enumerate(people):
node = Node(label="person", properties={"name": p, "val": idx})
graph.add_node(node)
nodes[p] = node
# Fully connected graph
for src in nodes:
for dest in nodes:
if src != dest:
edge = Edge(nodes[src], "know", nodes[dest])
graph.add_edge(edge)
for src in nodes:
for dest in nodes:
if src != dest:
edge = Edge(nodes[src], "works_with", nodes[dest])
graph.add_edge(edge)
graph.commit()
query = """MATCH (a)-[:know]->(b) CREATE (a)-[:know]->(b)"""
graph.query(query)
def expect_type_error(self, query):
try:
graph.query(query)
assert (False)
except redis.exceptions.ResponseError as e:
# Expecting a type error.
self.env.assertIn("Type mismatch", str(e))
def expect_error(self, query, expected_err_msg):
try:
graph.query(query)
assert (False)
except redis.exceptions.ResponseError as e:
# Expecting a type error.
self.env.assertIn(expected_err_msg, str(e))
# Validate capturing of errors prior to query execution.
def test01_compile_time_errors(self):
query = """RETURN toUpper(5)"""
self.expect_type_error(query)
query = """RETURN 'a' * 2"""
self.expect_type_error(query)
query = """RETURN max(1 + min(2))"""
self.expect_error(
query,
"Can't use aggregate functions inside of aggregate functions")
def test02_boolean_comparisons(self):
query = """RETURN true = 5"""
actual_result = graph.query(query)
expected_result = [[False]]
self.env.assertEquals(actual_result.result_set, expected_result)
query = """RETURN true <> 'str'"""
actual_result = graph.query(query)
expected_result = [[True]]
self.env.assertEquals(actual_result.result_set, expected_result)
query = """RETURN 'anything' <> NULL"""
actual_result = graph.query(query)
expected_result = [[None]]
self.env.assertEquals(actual_result.result_set, expected_result)
query = """RETURN 'anything' = NULL"""
actual_result = graph.query(query)
expected_result = [[None]]
self.env.assertEquals(actual_result.result_set, expected_result)
query = """RETURN 10 >= 1.5"""
actual_result = graph.query(query)
expected_result = [[True]]
self.env.assertEquals(actual_result.result_set, expected_result)
query = """RETURN -1 < 1"""
actual_result = graph.query(query)
expected_result = [[True]]
self.env.assertEquals(actual_result.result_set, expected_result)
def test03_boolean_errors(self):
query = """RETURN 'str' < 5.5"""
self.expect_type_error(query)
query = """RETURN true > 5"""
self.expect_type_error(query)
query = """MATCH (a) RETURN a < 'anything' LIMIT 1"""
self.expect_type_error(query)
def test04_entity_functions(self):
query = "RETURN ID(5)"
self.expect_type_error(query)
query = "MATCH (a) RETURN ID(a) ORDER BY ID(a) LIMIT 3"
actual_result = graph.query(query)
expected_result = [[0], [1], [2]]
self.env.assertEquals(actual_result.result_set, expected_result)
query = "MATCH (a)-[e]->() RETURN ID(e) ORDER BY ID(e) LIMIT 3"
actual_result = graph.query(query)
expected_result = [[0], [1], [2]]
self.env.assertEquals(actual_result.result_set, expected_result)
query = "RETURN EXISTS(null)"
actual_result = graph.query(query)
expected_result = [[False]]
self.env.assertEquals(actual_result.result_set, expected_result)
query = "RETURN EXISTS('anything')"
actual_result = graph.query(query)
expected_result = [[True]]
self.env.assertEquals(actual_result.result_set, expected_result)
def test07_nonmap_errors(self):
query = """MATCH (a) WITH a.name AS scalar RETURN scalar.name"""
self.expect_type_error(query)
def test08_apply_all_function(self):
query = "MATCH () RETURN COUNT(*)"
actual_result = graph.query(query)
expected_result = [[4]]
self.env.assertEquals(actual_result.result_set, expected_result)
query = "UNWIND [1, 2] AS a RETURN COUNT(*)"
actual_result = graph.query(query)
expected_result = [[2]]
self.env.assertEquals(actual_result.result_set, expected_result)
def test09_static_aggregation(self):
query = "RETURN count(*)"
actual_result = graph.query(query)
expected_result = [[1]]
self.env.assertEquals(actual_result.result_set, expected_result)
query = "RETURN max(2)"
actual_result = graph.query(query)
expected_result = [[2]]
self.env.assertEquals(actual_result.result_set, expected_result)
query = "RETURN min(3)"
actual_result = graph.query(query)
expected_result = [[3]]
self.env.assertEquals(actual_result.result_set, expected_result)
def test10_modulo_inputs(self):
# Validate modulo with integer inputs.
query = "RETURN 5 % 2"
actual_result = graph.query(query)
expected_result = [[1]]
self.env.assertEquals(actual_result.result_set, expected_result)
# Validate modulo with a floating-point dividend.
query = "RETURN 5.5 % 2"
actual_result = graph.query(query)
expected_result = [[1.5]]
self.env.assertEquals(actual_result.result_set, expected_result)
# Validate modulo with a floating-point divisor.
query = "RETURN 5 % 2.5"
actual_result = graph.query(query)
expected_result = [[0]]
self.env.assertEquals(actual_result.result_set, expected_result)
# Validate modulo with both a floating-point dividen and a floating-point divisor.
query = "RETURN 5.5 % 2.5"
actual_result = graph.query(query)
expected_result = [[0.5]]
self.env.assertEquals(actual_result.result_set, expected_result)
# Validate modulo with negative integer inputs.
query = "RETURN -5 % -2"
actual_result = graph.query(query)
expected_result = [[-1]]
self.env.assertEquals(actual_result.result_set, expected_result)
# Validate modulo with negative floating-point inputs.
query = "RETURN -5.5 % -2.5"
actual_result = graph.query(query)
expected_result = [[-0.5]]
self.env.assertEquals(actual_result.result_set, expected_result)
# Aggregate functions should handle null inputs appropriately.
def test11_null_aggregate_function_inputs(self):
# SUM should sum all non-null inputs.
query = """UNWIND [1, NULL, 3] AS a RETURN sum(a)"""
actual_result = graph.query(query)
expected_result = [[4]]
self.env.assertEquals(actual_result.result_set, expected_result)
# SUM should return 0 given a fully NULL input.
query = """WITH NULL AS a RETURN sum(a)"""
actual_result = graph.query(query)
expected_result = [[0]]
self.env.assertEquals(actual_result.result_set, expected_result)
# COUNT should count all non-null inputs.
query = """UNWIND [1, NULL, 3] AS a RETURN count(a)"""
actual_result = graph.query(query)
expected_result = [[2]]
self.env.assertEquals(actual_result.result_set, expected_result)
# COUNT should return 0 given a fully NULL input.
query = """WITH NULL AS a RETURN count(a)"""
actual_result = graph.query(query)
expected_result = [[0]]
self.env.assertEquals(actual_result.result_set, expected_result)
# COLLECT should ignore null inputs.
query = """UNWIND [1, NULL, 3] AS a RETURN collect(a)"""
actual_result = graph.query(query)
expected_result = [[[1, 3]]]
self.env.assertEquals(actual_result.result_set, expected_result)
# COLLECT should return an empty array on all null inputs.
query = """WITH NULL AS a RETURN collect(a)"""
actual_result = graph.query(query)
expected_result = [[[]]]
self.env.assertEquals(actual_result.result_set, expected_result)
# Verify that nested functions that perform heap allocations return properly.
def test12_nested_heap_functions(self):
query = """MATCH p = (n) WITH head(nodes(p)) AS node RETURN node.name ORDER BY node.name"""
actual_result = graph.query(query)
expected_result = [['Ailon'], ['Alon'], ['Boaz'], ['Roi']]
self.env.assertEquals(actual_result.result_set, expected_result)
# CASE...WHEN statements should properly handle NULL, false, and true evaluations.
def test13_case_when_inputs(self):
# Simple case form: single value evaluation.
query = """UNWIND [NULL, true, false] AS v RETURN v, CASE v WHEN true THEN v END"""
actual_result = graph.query(query)
expected_result = [[None, None], [True, True], [False, None]]
self.env.assertEquals(actual_result.result_set, expected_result)
query = """UNWIND [NULL, true, false] AS v RETURN v, CASE v WHEN true THEN v WHEN false THEN v END"""
actual_result = graph.query(query)
expected_result = [[None, None], [True, True], [False, False]]
self.env.assertEquals(actual_result.result_set, expected_result)
# Generic case form: evaluation for each case.
query = """UNWIND [NULL, true, false] AS v RETURN v, CASE WHEN v THEN v END"""
actual_result = graph.query(query)
# Only the true value should return non-NULL.
expected_result = [[None, None], [True, True], [False, None]]
self.env.assertEquals(actual_result.result_set, expected_result)
query = """UNWIND [NULL, true, false] AS v RETURN v, CASE WHEN v IS NOT NULL THEN v END"""
actual_result = graph.query(query)
# The true and false values should both return non-NULL.
expected_result = [[None, None], [True, True], [False, False]]
self.env.assertEquals(actual_result.result_set, expected_result)
# CASE...WHEN statements should manage allocated values properly.
def test14_case_when_memory_management(self):
# Simple case form: single value evaluation.
query = """WITH 'A' AS a WITH CASE a WHEN 'A' THEN toString(a) END AS key RETURN toLower(key)"""
actual_result = graph.query(query)
expected_result = [['a']]
self.env.assertEquals(actual_result.result_set, expected_result)
# Generic case form: evaluation for each case.
query = """WITH 'A' AS a WITH CASE WHEN true THEN toString(a) END AS key RETURN toLower(key)"""
actual_result = graph.query(query)
expected_result = [['a']]
self.env.assertEquals(actual_result.result_set, expected_result)
def test15_aggregate_error_handling(self):
functions = [
"avg", "collect", "count", "max", "min", "sum", "percentileDisc",
"percentileCont", "stDev"
]
# Test all functions for invalid argument counts.
for function in functions:
query = """UNWIND range(0, 10) AS val RETURN %s(val, val, val)""" % (
function)
self.expect_error(query, "Received 3 arguments")
# Test numeric functions for invalid input types.
numeric_functions = ["avg", "sum", "stDev"]
for function in numeric_functions:
query = """UNWIND ['a', 'b', 'c'] AS val RETURN %s(val)""" % (
function)
self.expect_type_error(query)
# Test invalid numeric input for percentile function.
query = """UNWIND range(0, 10) AS val RETURN percentileDisc(val, -1)"""
self.expect_error(query, "must be a number in the range 0.0 to 1.0")
# startNode and endNode calls should return the appropriate nodes.
def test16_edge_endpoints(self):
query = """MATCH (a)-[e]->(b) RETURN a.name, startNode(e).name, b.name, endNode(e).name"""
actual_result = graph.query(query)
for row in actual_result.result_set:
self.env.assertEquals(row[0], row[1])
self.env.assertEquals(row[2], row[3])
def testDictDeleteWrongArity():
env = Env()
env.expect('ft.dictdel', 'dict').raiseError()
class testImdbFlow(FlowTestsBase):
def __init__(self):
self.env = Env()
def setUp(self):
global imdb
global queries
global redis_graph
redis_con = self.env.getConnection()
redis_graph = Graph(imdb_utils.graph_name, redis_con)
actors, movies = imdb_utils.populate_graph(redis_con, redis_graph)
imdb = imdb_queries.IMDBQueries(actors, movies)
queries = imdb.queries()
def tearDown(self):
self.env.cmd('flushall')
def assert_reversed_pattern(self, query, resultset):
# Test reversed pattern query.
reversed_query = ReversePattern().reverse_query_pattern(query)
# print "reversed_query: %s" % reversed_query
actual_result = redis_graph.query(reversed_query)
# assert result set
self.env.assertEqual(resultset.result_set, actual_result.result_set)
# assert query run time
self._assert_equalish(resultset.run_time_ms, actual_result.run_time_ms)
def test_imdb(self):
for q in queries:
query = q.query
actual_result = redis_graph.query(query)
# assert result set
self._assert_only_expected_results_are_in_actual_results(
actual_result, q)
# assert query run time
self._assert_run_time(actual_result, q)
if q.reversible:
# assert reversed pattern.
self.assert_reversed_pattern(query, actual_result)
def test_index_scan_actors_over_85(self):
global redis_graph
# Execute this command directly, as its response does not contain the result set that
# 'redis_graph.query()' expects
redis_con = self.env.getConnection()
res = redis_con.execute_command("GRAPH.QUERY", redis_graph.name,
"CREATE INDEX ON :actor(age)")
q = imdb.actors_over_85_index_scan.query
execution_plan = redis_graph.execution_plan(q)
self.env.assertIn('Index Scan', execution_plan)
actual_result = redis_graph.query(q)
redis_con.execute_command("GRAPH.QUERY", redis_graph.name,
"DROP INDEX ON :actor(age)")
# assert result set
self._assert_only_expected_results_are_in_actual_results(
actual_result, imdb.actors_over_85_index_scan)
# assert query run time
self._assert_run_time(actual_result, imdb.actors_over_85_index_scan)
# assert reversed pattern.
self.assert_reversed_pattern(q, actual_result)
def test_index_scan_eighties_movies(self):
global redis_graph
# Execute this command directly, as its response does not contain the result set that
# 'redis_graph.query()' expects
redis_graph.redis_con.execute_command("GRAPH.QUERY", redis_graph.name,
"CREATE INDEX ON :movie(year)")
q = imdb.eighties_movies_index_scan.query
execution_plan = redis_graph.execution_plan(q)
self.env.assertIn('Index Scan', execution_plan)
actual_result = redis_graph.query(q)
redis_graph.redis_con.execute_command("GRAPH.QUERY", redis_graph.name,
"DROP INDEX ON :movie(year)")
# assert result set
self._assert_only_expected_results_are_in_actual_results(
actual_result, imdb.eighties_movies_index_scan)
# assert query run time
self._assert_run_time(actual_result, imdb.eighties_movies_index_scan)
# assert reversed pattern.
self.assert_reversed_pattern(q, actual_result)
def testDictAdd():
env = Env()
env.expect('ft.dictadd', 'dict', 'term1', 'term2', 'term3').equal(3)
env.expect('ft.dictadd', 'dict', 'term1', 'term2', 'term4').equal(1)
def __init__(self):
self.env = Env()
def testDictDumpWrongArity():
env = Env()
env.expect('ft.dictdump').raiseError()
def __init__(self):
if CONTAINS_MODULES is not None:
self.env = Env(moduleArgs='DUPLICATE_POLICY BLOCK')
checkSampleModules(self.env)
else:
print("Skipping test given there is no module")
def testBasicSpellCheck():
env = Env()
env.cmd('ft.create', 'idx', 'SCHEMA', 'name', 'TEXT', 'body', 'TEXT')
env.cmd('ft.add', 'idx', 'doc1', 1.0, 'FIELDS', 'name', 'name1', 'body', 'body1')
env.cmd('ft.add', 'idx', 'doc2', 1.0, 'FIELDS', 'name', 'name2', 'body', 'body2')
env.cmd('ft.add', 'idx', 'doc3', 1.0, 'FIELDS', 'name', 'name2', 'body', 'name2')
env.expect('ft.spellcheck', 'idx', 'name').equal([['TERM', 'name',
[['0.66666666666666663', 'name2'], ['0.33333333333333331', 'name1']]]])
if not env.isCluster():
env.expect('ft.spellcheck', 'idx', '@body:name').equal([['TERM', 'name', [['0.66666666666666663', 'name2']]]])
class testValueComparison(FlowTestsBase):
def __init__(self):
self.env = Env()
global redis_graph
redis_con = self.env.getConnection()
redis_graph = Graph("G", redis_con)
self.populate_graph()
@classmethod
def populate_graph(self):
global redis_graph
for v in values:
node = Node(label="value", properties={"val": v})
redis_graph.add_node(node)
# Add an additional node with no properties
redis_graph.add_node(Node(label="value"))
redis_graph.commit()
# Verify the ordering of values that can and cannot be directly compared
def test_orderability(self):
query = """MATCH (v:value) RETURN v.val ORDER BY v.val"""
actual_result = redis_graph.query(query)
expected = [['str1'], ['str2'], [False], [True], [5], [10.5], [None]]
self.env.assertEquals(actual_result.result_set, expected)
# Expect the results to appear in reverse when using descending order
query = """MATCH (v:value) RETURN v.val ORDER BY v.val DESC"""
actual_result = redis_graph.query(query)
self.env.assertEquals(actual_result.result_set, expected[::-1])
# From the Cypher specification:
# "In a mixed set, any numeric value is always considered to be higher than any string value"
def test_mixed_type_min(self):
query = """MATCH (v:value) RETURN MIN(v.val)"""
actual_result = redis_graph.query(query)
self.env.assertEquals(actual_result.result_set[0][0], 'str1')
def test_mixed_type_max(self):
query = """MATCH (v:value) RETURN MAX(v.val)"""
actual_result = redis_graph.query(query)
self.env.assertEquals(actual_result.result_set[0][0], 10.5)
# Verify that disjoint types pass <> filters
def test_disjoint_comparisons(self):
# Compare all node pairs under a Cartesian product
query = """MATCH (v:value), (w:value) WHERE ID(v) <> ID(w) AND v.val = w.val RETURN v"""
actual_result = redis_graph.query(query)
# No nodes have the same property, so there should be 0 equal results
expected_result_count = 0
self.env.assertEquals(len(actual_result.result_set),
expected_result_count)
query = """MATCH (v:value), (w:value) WHERE ID(v) <> ID(w) AND v.val <> w.val RETURN v"""
actual_result = redis_graph.query(query)
# Every comparison should produce an inequal result
node_count = len(redis_graph.nodes)
# The node with value set as "null" should not be returned or be part of evaluation.
expected_result_count = (node_count - 1) * (node_count - 2)
self.env.assertEquals(len(actual_result.result_set),
expected_result_count)
# Verify that comparisons between very small and very large values are ordered properly.
def test_large_comparisons(self):
query = """UNWIND [933, 1099511628237] AS val RETURN val ORDER BY val"""
actual_result = redis_graph.query(query)
expected = [[933], [1099511628237]]
self.env.assertEquals(actual_result.result_set, expected)
# Verify that AND conditions on true, false, and NULL values evaluate appropriately
def test_AND_truth_tables(self):
# Test two non-NULL values
query = """RETURN true AND true, true AND false, false AND true, false AND false"""
actual_result = redis_graph.query(query)
expected_val = [True, False, False, False] # Truth table for AND
self.env.assertEquals(actual_result.result_set[0], expected_val)
# false AND null == false
query = """RETURN false AND NULL"""
actual_result = redis_graph.query(query)
self.env.assertEquals(actual_result.result_set[0][0], False)
# true AND null == null
query = """RETURN true AND NULL"""
actual_result = redis_graph.query(query)
self.env.assertEquals(actual_result.result_set[0][0], None)
# Test two NULL values
query = """RETURN NULL AND NULL"""
actual_result = redis_graph.query(query)
# AND comparisons with two NULL values evaluate to NULL
self.env.assertEquals(actual_result.result_set[0][0], None)
# Verify that OR conditions on true, false, and NULL values evaluate appropriately
def test_OR_truth_tables(self):
# Test two non-NULL values
query = """RETURN true OR true, true OR false, false OR true, false OR false"""
actual_result = redis_graph.query(query)
expected_val = [True, True, True, False] # Truth table for OR
self.env.assertEquals(actual_result.result_set[0], expected_val)
# false OR null == null
query = """RETURN false OR NULL"""
actual_result = redis_graph.query(query)
self.env.assertEquals(actual_result.result_set[0][0], None)
# true OR null == true
query = """RETURN true OR NULL"""
actual_result = redis_graph.query(query)
self.env.assertEquals(actual_result.result_set[0][0], True)
# null OR null == null
query = """RETURN NULL OR NULL"""
actual_result = redis_graph.query(query)
self.env.assertEquals(actual_result.result_set[0][0], None)
# Verify that XOR conditions on true, false, and NULL values evaluate appropriately
def test_XOR_truth_tables(self):
# Test two non-NULL values
query = """RETURN true XOR true, true XOR false, false XOR true, false XOR false"""
actual_result = redis_graph.query(query)
expected_val = [False, True, True, False] # Truth table for XOR
self.env.assertEquals(actual_result.result_set[0], expected_val)
# Test one NULL value
query = """RETURN true XOR null, false XOR null"""
actual_result = redis_graph.query(query)
# XOR comparisons with one NULL value always evaluate to null
expected_val = [None, None]
self.env.assertEquals(actual_result.result_set[0], expected_val)
# Test two NULL values
query = """RETURN NULL XOR NULL"""
actual_result = redis_graph.query(query)
# XOR comparisons with two NULL values evaluate to NULL
self.env.assertEquals(actual_result.result_set[0][0], None)
# Verify that NOT conditions on true, false, and NULL values evaluate appropriately
def test_NOT_truth_tables(self):
# Test non-NULL values
query = """RETURN NOT true, NOT false"""
actual_result = redis_graph.query(query)
expected_val = [False, True] # Truth table (single-valued) for NOT
self.env.assertEquals(actual_result.result_set[0], expected_val)
# NOT null == null
query = """RETURN NOT NULL"""
actual_result = redis_graph.query(query)
self.env.assertEquals(actual_result.result_set[0][0], None)
def test_coalesce(self):
query = """MATCH (n) RETURN COALESCE(n.a, n.b, n.c)"""
actual_result = redis_graph.query(query)
# Test default value - everything is null.
self.env.assertEquals(
[[None], [None], [None], [None], [None], [None], [None]],
actual_result.result_set)
query = """MATCH (n) SET n.c = 'c' RETURN COALESCE(n.a, n.b, n.c)"""
actual_result = redis_graph.query(query)
# Test value search, last expressions is not null.
self.env.assertEquals(
[['c'], ['c'], ['c'], ['c'], ['c'], ['c'], ['c']],
actual_result.result_set)
query = """MATCH (n) SET n.b = 2 RETURN COALESCE(n.a, n.b, n.c)"""
actual_result = redis_graph.query(query)
# Test value search, second expressions is not null.
self.env.assertEquals([[2], [2], [2], [2], [2], [2], [2]],
actual_result.result_set)
query = """MATCH (n) SET n.a = 1.1 RETURN COALESCE(n.a, n.b, n.c)"""
actual_result = redis_graph.query(query)
# Test value search, first expressions is not null.
self.env.assertEquals(
[[1.1], [1.1], [1.1], [1.1], [1.1], [1.1], [1.1]],
actual_result.result_set)
def __init__(self):
self.env = Env()
global redis_graph
redis_con = self.env.getConnection()
redis_graph = Graph("G", redis_con)
self.populate_graph()
def testDocTable():
env = Env(moduleArgs='MAXDOCTABLESIZE 100')
env.assertOk(
env.execute_command('ft.create', 'idx', 'schema', 'title', 'text',
'body', 'text'))
# doc table size is 100 so insearting 1000 docs should gives us 10 docs in each bucket
for i in range(1000):
env.assertOk(
env.execute_command('ft.add', 'idx', 'doc%d' % i, 1.0, 'fields',
'title', 'hello world %d' % (i % 100), 'body',
'lorem ist ipsum'))
for i in range(100):
res = env.execute_command('ft.search', 'idx', 'hello world %d' % i)
env.assertEqual(res[0], 10)
# deleting the first 100 docs
for i in range(100):
env.assertEqual(env.execute_command('ft.del', 'idx', 'doc%d' % i), 1)
for i in range(100):
res = env.execute_command('ft.search', 'idx', 'hello world %d' % i)
env.assertEqual(res[0], 9)
env.assertOk(env.execute_command('ft.drop', 'idx'))
def testSpellCheckWithDuplications():
env = Env()
env.cmd('ft.dictadd', 'dict', 'name1', 'name4', 'name5')
env.cmd('ft.create', 'idx', 'SCHEMA', 'name', 'TEXT', 'body', 'TEXT')
env.cmd('ft.add', 'idx', 'doc1', 1.0, 'FIELDS', 'name', 'name1', 'body', 'body1')
env.cmd('ft.add', 'idx', 'doc2', 1.0, 'FIELDS', 'name', 'name2', 'body', 'body2')
env.cmd('ft.add', 'idx', 'doc3', 1.0, 'FIELDS', 'name', 'name2', 'body', 'name2')
env.expect('ft.spellcheck', 'idx', 'name', 'TERMS', 'INCLUDE', 'dict').equal([['TERM', 'name',
[['0.66666666666666663', 'name2'],
['0.33333333333333331', 'name1'],
['0', 'name4'], ['0', 'name5']]]])
class test_read_only_query(FlowTestsBase):
def __init__(self):
if Env().envRunner.debugger is not None:
Env().skip() # valgrind is not working correctly with replication
self.env = Env(useSlaves=True)
global master_con
global slave_con
master_con = self.env.getConnection()
slave_con = self.env.getSlaveConnection()
def test01_test_simple_read_only_command(self):
# This test check graph.RO_QUERY to execute read only commands with success.
graph_name = "Test_RO_QUERY_command"
graph = Graph(graph_name, master_con)
graph.query("UNWIND range(0,20) as i CREATE ()")
raw_result_set = master_con.execute_command("GRAPH.RO_QUERY", graph_name, "MATCH (n) RETURN COUNT(n)", "--compact")
result_set = query_result.QueryResult(graph, raw_result_set).result_set
self.env.assertEqual(21, result_set[0][0])
# Try execute write commands with RO_QUERY
try:
master_con.execute_command("GRAPH.RO_QUERY", graph_name, "CREATE()", "--compact")
assert(False)
except:
# Expecting an error.
pass
def test02_test_RO_QUERY_fail_on_write_operations(self):
# This test check graph.RO_QUERY to execute read only commands with success.
graph_name = "Test_RO_QUERY_fail_on_write_command"
graph = Graph(graph_name, master_con)
# Try execute write commands with RO_QUERY
try:
master_con.execute_command("GRAPH.RO_QUERY", graph_name, "CREATE()", "--compact")
assert(False)
except:
# Expecting an error.
pass
try:
master_con.execute_command("GRAPH.RO_QUERY", graph_name, "MERGE()", "--compact")
assert(False)
except:
# Expecting an error.
pass
try:
master_con.execute_command("GRAPH.RO_QUERY", graph_name, "MATCH(n) DELETE n", "--compact")
assert(False)
except:
# Expecting an error.
pass
try:
master_con.execute_command("GRAPH.RO_QUERY", graph_name, "CREATE INDEX ON :person(age)", "--compact")
assert(False)
except:
# Expecting an error.
pass
try:
master_con.execute_command("GRAPH.RO_QUERY", graph_name, "DROP INDEX ON :Person(age)", "--compact")
assert(False)
except:
# Expecting an error.
pass
def test03_test_replica_read_only(self):
# This test checks that only RO_QUERY is valid on replicas.
graph_name = "Test_RO_QUERY_command_on_replica"
graph = Graph(graph_name, master_con)
graph.query("UNWIND range(0,20) as i CREATE ()")
slave_con.execute_command("REPLICAOF", "localhost", "6379")
checkSlaveSynced(self.env, slave_con, graph_name)
raw_result_set = slave_con.execute_command("GRAPH.RO_QUERY", graph_name, "MATCH (n) RETURN COUNT(n)", "--compact")
result_set = query_result.QueryResult(graph, raw_result_set).result_set
self.env.assertEqual(21, result_set[0][0])
try:
# Every GRAPH.QUERY command is a write command, see that replica connection throws an exception.
slave_con.execute_command("GRAPH.QUERY", graph_name, "MATCH (n) RETURN COUNT(n)", "--compact")
assert(False)
except:
# Expecting an error.
pass
def testRawAof():
env = Env(useAof=True)
aofTestCommon(env, lambda: env.broadcast('debug', 'loadaof'))
def testAof():
env = Env(useAof=True)
aofTestCommon(env, lambda: env.restart_and_reload())
def testAofRewriteSortkeys():
env = Env(useAof=True)
env.cmd('FT.CREATE', 'idx', 'SCHEMA', 'foo',
'TEXT', 'SORTABLE', 'bar', 'TAG')
env.cmd('FT.ADD', 'idx', '1', '1', 'FIELDS', 'foo', 'A', 'bar', '1')
env.cmd('FT.ADD', 'idx', '2', '1', 'fields', 'foo', 'B', 'bar', '1')
res_exp = env.cmd('FT.SEARCH', 'idx', '@bar:{1}', 'SORTBY', 'foo', 'ASC',
'RETURN', '1', 'foo', 'WITHSORTKEYS')
env.restart_and_reload()
res_got = env.cmd('FT.SEARCH', 'idx', '@bar:{1}', 'SORTBY', 'foo', 'ASC',
'RETURN', '1', 'foo', 'WITHSORTKEYS')
env.assertEqual(res_exp, res_got)
def testRawAof():
env = Env(useAof=True)
if env.env == 'existing-env':
env.skip()
aofTestCommon(env, lambda: env.broadcast('debug', 'loadaof'))
class TestDebugCommands(object):
def __init__(self):
self.env = Env(testName="testing debug commands")
self.env.skipOnCluster()
self.env.expect('FT.CREATE', 'idx', 'SCHEMA', 'name', 'TEXT', 'SORTABLE', 'age', 'NUMERIC', 'SORTABLE', 't', 'TAG', 'SORTABLE').ok()
self.env.expect('FT.ADD', 'idx', 'doc1', '1.0', 'FIELDS', 'name', 'meir', 'age', '29', 't', 'test').ok()
def testDebugWrongArity(self):
self.env.expect('FT.DEBUG', 'dump_invidx').raiseError().equal("wrong number of arguments for 'FT.DEBUG' command")
def testDebugUnknownSubcommand(self):
self.env.expect('FT.DEBUG', 'unknown').raiseError().equal('subcommand was not found')
def testDumpInvertedIndex(self):
self.env.expect('FT.DEBUG', 'dump_invidx', 'idx', 'meir').equal([1])
self.env.expect('FT.DEBUG', 'DUMP_INVIDX', 'idx', 'meir').equal([1])
def testDumpInvertedIndexWrongArity(self):
self.env.expect('FT.DEBUG', 'dump_invidx', 'idx').raiseError()
def testDumpUnexistsInvertedIndex(self):
self.env.expect('FT.DEBUG', 'dump_invidx', 'idx', 'meir1').raiseError()
def testDumpInvertedIndexInvalidSchema(self):
self.env.expect('FT.DEBUG', 'dump_invidx', 'idx1', 'meir').raiseError()
def testDumpNumericIndex(self):
self.env.expect('FT.DEBUG', 'dump_numidx', 'idx', 'age').equal([[1L]])
self.env.expect('FT.DEBUG', 'DUMP_NUMIDX', 'idx', 'age').equal([[1L]])
def testDumpNumericIndexWrongArity(self):
self.env.expect('FT.DEBUG', 'dump_numidx', 'idx').raiseError()
def testDumpUnexistsNumericIndex(self):
self.env.expect('FT.DEBUG', 'dump_numidx', 'idx', 'ag1').raiseError()
def testDumpNumericIndexInvalidSchema(self):
self.env.expect('FT.DEBUG', 'dump_numidx', 'idx1', 'age').raiseError()
def testDumpTagIndex(self):
self.env.expect('FT.DEBUG', 'dump_tagidx', 'idx', 't').equal([['test', [1L]]])
self.env.expect('FT.DEBUG', 'DUMP_TAGIDX', 'idx', 't').equal([['test', [1L]]])
def testDumpTagIndexWrongArity(self):
self.env.expect('FT.DEBUG', 'dump_tagidx', 'idx').raiseError()
def testDumpUnexistsTagIndex(self):
self.env.expect('FT.DEBUG', 'dump_tagidx', 'idx', 't1').raiseError()
def testDumpTagIndexInvalidSchema(self):
self.env.expect('FT.DEBUG', 'dump_tagidx', 'idx1', 't').raiseError()
def testDocIdToId(self):
self.env.expect('FT.DEBUG', 'docidtoid', 'idx', 'doc1').equal(1)
self.env.expect('FT.DEBUG', 'DOCIDTOID', 'idx', 'doc1').equal(1)
def testDocIdToIdOnUnexistingDoc(self):
self.env.expect('FT.DEBUG', 'docidtoid', 'idx', 'doc').equal(0)
def testIdToDocId(self):
self.env.expect('FT.DEBUG', 'idtodocid', 'idx', '1').equal('doc1')
self.env.expect('FT.DEBUG', 'IDTODOCID', 'idx', '1').equal('doc1')
def testIdToDocIdOnUnexistingId(self):
self.env.expect('FT.DEBUG', 'idtodocid', 'idx', '2').raiseError().equal('document was removed')
def testDumpPhoneticHash(self):
self.env.expect('FT.DEBUG', 'dump_phonetic_hash', 'test').equal(['<TST', '<TST'])
self.env.expect('FT.DEBUG', 'DUMP_PHONETIC_HASH', 'test').equal(['<TST', '<TST'])
def testDumpPhoneticHashWrongArity(self):
self.env.expect('FT.DEBUG', 'dump_phonetic_hash').raiseError()
def testDumpTerms(self):
self.env.expect('FT.DEBUG', 'dump_terms', 'idx').equal(['meir'])
self.env.expect('FT.DEBUG', 'DUMP_TERMS', 'idx').equal(['meir'])
def testDumpTermsWrongArity(self):
self.env.expect('FT.DEBUG', 'dump_terms').raiseError()
def testDumpTermsUnknownIndex(self):
self.env.expect('FT.DEBUG', 'dump_terms', 'idx1').raiseError()
def testInvertedIndexSummary(self):
self.env.expect('FT.DEBUG', 'invidx_summary', 'idx', 'meir').equal(['numDocs', 1L, 'lastId', 1L, 'flags',
83L, 'numberOfBlocks', 1L, 'blocks',
['firstId', 1L, 'lastId', 1L, 'numDocs', 1L]])
self.env.expect('FT.DEBUG', 'INVIDX_SUMMARY', 'idx', 'meir').equal(['numDocs', 1L, 'lastId', 1L, 'flags',
83L, 'numberOfBlocks', 1L, 'blocks',
['firstId', 1L, 'lastId', 1L, 'numDocs', 1L]])
def testUnexistsInvertedIndexSummary(self):
self.env.expect('FT.DEBUG', 'invidx_summary', 'idx', 'meir1').raiseError()
def testInvertedIndexSummaryInvalidIdxName(self):
self.env.expect('FT.DEBUG', 'invidx_summary', 'idx1', 'meir').raiseError()
def testInvertedIndexSummaryWrongArity(self):
self.env.expect('FT.DEBUG', 'invidx_summary', 'idx1').raiseError()
def testNumericIdxIndexSummary(self):
self.env.expect('FT.DEBUG', 'numidx_summary', 'idx', 'age').equal(['numRanges', 1L, 'numEntries', 1L,
'lastDocId', 1L, 'revisionId', 0L])
self.env.expect('FT.DEBUG', 'NUMIDX_SUMMARY', 'idx', 'age').equal(['numRanges', 1L, 'numEntries', 1L,
'lastDocId', 1L, 'revisionId', 0L])
def testUnexistsNumericIndexSummary(self):
self.env.expect('FT.DEBUG', 'numidx_summary', 'idx', 'age1').raiseError()
def testNumericIndexSummaryInvalidIdxName(self):
self.env.expect('FT.DEBUG', 'numidx_summary', 'idx1', 'age').raiseError()
def testNumericIndexSummaryWrongArity(self):
self.env.expect('FT.DEBUG', 'numidx_summary', 'idx1').raiseError()
def testRewriteAofSortables():
env = Env(useAof=True)
env.cmd('FT.CREATE', 'idx', 'ON', 'HASH', 'schema', 'field1', 'TEXT',
'SORTABLE', 'num1', 'NUMERIC', 'SORTABLE')
env.cmd('FT.ADD', 'idx', 'doc', 1.0, 'FIELDS', 'field1', 'Hello World')
env.restart_and_reload()
env.broadcast('SAVE')
# Load some documents
for x in xrange(100):
env.cmd('FT.ADD', 'idx', 'doc{}'.format(x), 1.0, 'FIELDS', 'field1',
'txt{}'.format(random.random()), 'num1', random.random())
for sspec in [('field1', 'asc'), ('num1', 'desc')]:
cmd = ['FT.SEARCH', 'idx', 'txt', 'SORTBY', sspec[0], sspec[1]]
res = env.cmd(*cmd)
env.restart_and_reload()
res2 = env.cmd(*cmd)
env.assertEqual(res, res2)
def testGCIntegrationWithRedisFork(env):
if env.isCluster():
raise unittest.SkipTest()
env = Env(moduleArgs='GC_POLICY FORK')
env.expect('FT.CONFIG', 'SET', 'FORKGC_SLEEP_BEFORE_EXIT', '4').ok()
env.expect('FT.CREATE', 'idx', 'SCHEMA', 'title', 'TEXT', 'SORTABLE').ok()
env.expect('FT.ADD', 'idx', 'doc1', 1.0, 'FIELDS', 'title', 'hello world').ok()
env.expect('bgsave').equal('Background saving started')
env.cmd('FT.DEBUG', 'GC_FORCEINVOKE', 'idx')
env.expect('bgsave').equal('Background saving started')
class TestAggregate():
def __init__(self):
self.env = Env()
add_values(self.env)
def testGroupBy(self):
cmd = ['ft.aggregate', 'games', '*',
'GROUPBY', '1', '@brand',
'REDUCE', 'count', '0', 'AS', 'count',
'SORTBY', 2, '@count', 'desc',
'LIMIT', '0', '5'
]
res = self.env.cmd(*cmd)
self.env.assertIsNotNone(res)
self.env.assertEqual([292L, ['brand', '', 'count', '1518'], ['brand', 'mad catz', 'count', '43'],
['brand', 'generic', 'count', '40'], ['brand', 'steelseries', 'count', '37'],
['brand', 'logitech', 'count', '35']], res)
def testMinMax(self):
cmd = ['ft.aggregate', 'games', 'sony',
'GROUPBY', '1', '@brand',
'REDUCE', 'count', '0',
'REDUCE', 'min', '1', '@price', 'as', 'minPrice',
'SORTBY', '2', '@minPrice', 'DESC']
res = self.env.cmd(*cmd)
self.env.assertIsNotNone(res)
row = to_dict(res[1])
self.env.assertEqual(88, int(float(row['minPrice'])))
cmd = ['ft.aggregate', 'games', 'sony',
'GROUPBY', '1', '@brand',
'REDUCE', 'count', '0',
'REDUCE', 'max', '1', '@price', 'as', 'maxPrice',
'SORTBY', '2', '@maxPrice', 'DESC']
res = self.env.cmd(*cmd)
row = to_dict(res[1])
self.env.assertEqual(695, int(float(row['maxPrice'])))
def testAvg(self):
cmd = ['ft.aggregate', 'games', 'sony',
'GROUPBY', '1', '@brand',
'REDUCE', 'avg', '1', '@price', 'AS', 'avg_price',
'REDUCE', 'count', '0',
'SORTBY', '2', '@avg_price', 'DESC']
res = self.env.cmd(*cmd)
self.env.assertIsNotNone(res)
self.env.assertEqual(26, res[0])
# Ensure the formatting actually exists
first_row = to_dict(res[1])
self.env.assertEqual(109, int(float(first_row['avg_price'])))
for row in res[1:]:
row = to_dict(row)
self.env.assertIn('avg_price', row)
# Test aliasing
cmd = ['FT.AGGREGATE', 'games', 'sony', 'GROUPBY', '1', '@brand',
'REDUCE', 'avg', '1', '@price', 'AS', 'avgPrice']
res = self.env.cmd(*cmd)
first_row = to_dict(res[1])
self.env.assertEqual(17, int(float(first_row['avgPrice'])))
def testCountDistinct(self):
cmd = ['FT.AGGREGATE', 'games', '*',
'GROUPBY', '1', '@brand',
'REDUCE', 'COUNT_DISTINCT', '1', '@title', 'AS', 'count_distinct(title)',
'REDUCE', 'COUNT', '0'
]
res = self.env.cmd(*cmd)[1:]
# print res
row = to_dict(res[0])
self.env.assertEqual(1484, int(row['count_distinct(title)']))
cmd = ['FT.AGGREGATE', 'games', '*',
'GROUPBY', '1', '@brand',
'REDUCE', 'COUNT_DISTINCTISH', '1', '@title', 'AS', 'count_distinctish(title)',
'REDUCE', 'COUNT', '0'
]
res = self.env.cmd(*cmd)[1:]
# print res
row = to_dict(res[0])
self.env.assertEqual(1461, int(row['count_distinctish(title)']))
def testQuantile(self):
cmd = ['FT.AGGREGATE', 'games', '*',
'GROUPBY', '1', '@brand',
'REDUCE', 'QUANTILE', '2', '@price', '0.50', 'AS', 'q50',
'REDUCE', 'QUANTILE', '2', '@price', '0.90', 'AS', 'q90',
'REDUCE', 'QUANTILE', '2', '@price', '0.95', 'AS', 'q95',
'REDUCE', 'AVG', '1', '@price',
'REDUCE', 'COUNT', '0', 'AS', 'rowcount',
'SORTBY', '2', '@rowcount', 'DESC', 'MAX', '1']
res = self.env.cmd(*cmd)
row = to_dict(res[1])
# TODO: Better samples
self.env.assertAlmostEqual(14.99, float(row['q50']), delta=3)
self.env.assertAlmostEqual(70, float(row['q90']), delta=50)
# This tests the 95th percentile, which is error prone because
# so few samples actually exist. I'm disabling it for now so that
# there is no breakage in CI
# self.env.assertAlmostEqual(110, (float(row['q95'])), delta=50)
def testStdDev(self):
cmd = ['FT.AGGREGATE', 'games', '*',
'GROUPBY', '1', '@brand',
'REDUCE', 'STDDEV', '1', '@price', 'AS', 'stddev(price)',
'REDUCE', 'AVG', '1', '@price', 'AS', 'avgPrice',
'REDUCE', 'QUANTILE', '2', '@price', '0.50', 'AS', 'q50Price',
'REDUCE', 'COUNT', '0', 'AS', 'rowcount',
'SORTBY', '2', '@rowcount', 'DESC',
'LIMIT', '0', '10']
res = self.env.cmd(*cmd)
row = to_dict(res[1])
self.env.assertTrue(10 <= int(
float(row['q50Price'])) <= 20)
self.env.assertAlmostEqual(53, int(float(row['stddev(price)'])), delta=50)
self.env.assertEqual(29, int(float(row['avgPrice'])))
def testParseTime(self):
cmd = ['FT.AGGREGATE', 'games', '*',
'GROUPBY', '1', '@brand',
'REDUCE', 'COUNT', '0', 'AS', 'count',
'APPLY', 'timefmt(1517417144)', 'AS', 'dt',
'APPLY', 'parse_time("%FT%TZ", @dt)', 'as', 'parsed_dt',
'LIMIT', '0', '1']
res = self.env.cmd(*cmd)
self.env.assertEqual(['brand', '', 'count', '1518', 'dt',
'2018-01-31T16:45:44Z', 'parsed_dt', '1517417144'], res[1])
def testRandomSample(self):
cmd = ['FT.AGGREGATE', 'games', '*', 'GROUPBY', '1', '@brand',
'REDUCE', 'COUNT', '0', 'AS', 'num',
'REDUCE', 'RANDOM_SAMPLE', '2', '@price', '10',
'SORTBY', '2', '@num', 'DESC', 'MAX', '10']
for row in self.env.cmd(*cmd)[1:]:
self.env.assertIsInstance(row[5], list)
self.env.assertGreater(len(row[5]), 0)
self.env.assertGreaterEqual(row[3], len(row[5]))
self.env.assertLessEqual(len(row[5]), 10)
def testTimeFunctions(self):
cmd = ['FT.AGGREGATE', 'games', '*',
'APPLY', '1517417144', 'AS', 'dt',
'APPLY', 'timefmt(@dt)', 'AS', 'timefmt',
'APPLY', 'day(@dt)', 'AS', 'day',
'APPLY', 'hour(@dt)', 'AS', 'hour',
'APPLY', 'minute(@dt)', 'AS', 'minute',
'APPLY', 'month(@dt)', 'AS', 'month',
'APPLY', 'dayofweek(@dt)', 'AS', 'dayofweek',
'APPLY', 'dayofmonth(@dt)', 'AS', 'dayofmonth',
'APPLY', 'dayofyear(@dt)', 'AS', 'dayofyear',
'APPLY', 'year(@dt)', 'AS', 'year',
'LIMIT', '0', '1']
res = self.env.cmd(*cmd)
self.env.assertListEqual([1L, ['dt', '1517417144', 'timefmt', '2018-01-31T16:45:44Z', 'day', '1517356800', 'hour', '1517414400',
'minute', '1517417100', 'month', '1514764800', 'dayofweek', '3', 'dayofmonth', '31', 'dayofyear', '30', 'year', '2018']], res)
def testStringFormat(self):
cmd = ['FT.AGGREGATE', 'games', '@brand:sony',
'GROUPBY', '2', '@title', '@brand',
'REDUCE', 'COUNT', '0',
'REDUCE', 'MAX', '1', '@price', 'AS', 'price',
'APPLY', 'format("%s|%s|%s|%s", @title, @brand, "Mark", @price)', 'as', 'titleBrand',
'LIMIT', '0', '10']
res = self.env.cmd(*cmd)
for row in res[1:]:
row = to_dict(row)
expected = '%s|%s|%s|%g' % (
row['title'], row['brand'], 'Mark', float(row['price']))
self.env.assertEqual(expected, row['titleBrand'])
def testSum(self):
cmd = ['ft.aggregate', 'games', '*',
'GROUPBY', '1', '@brand',
'REDUCE', 'count', '0', 'AS', 'count',
'REDUCE', 'sum', 1, '@price', 'AS', 'sum(price)',
'SORTBY', 2, '@sum(price)', 'desc',
'LIMIT', '0', '5'
]
res = self.env.cmd(*cmd)
self.env.assertEqual([292L, ['brand', '', 'count', '1518', 'sum(price)', '44780.69'],
['brand', 'mad catz', 'count',
'43', 'sum(price)', '3973.48'],
['brand', 'razer', 'count', '26',
'sum(price)', '2558.58'],
['brand', 'logitech', 'count',
'35', 'sum(price)', '2329.21'],
['brand', 'steelseries', 'count', '37', 'sum(price)', '1851.12']], res)
def testFilter(self):
cmd = ['ft.aggregate', 'games', '*',
'GROUPBY', '1', '@brand',
'REDUCE', 'count', '0', 'AS', 'count',
'FILTER', '@count > 5'
]
res = self.env.cmd(*cmd)
for row in res[1:]:
row = to_dict(row)
self.env.assertGreater(int(row['count']), 5)
cmd = ['ft.aggregate', 'games', '*',
'GROUPBY', '1', '@brand',
'REDUCE', 'count', '0', 'AS', 'count',
'FILTER', '@count < 5',
'FILTER', '@count > 2 && @brand != ""'
]
res = self.env.cmd(*cmd)
for row in res[1:]:
row = to_dict(row)
self.env.assertLess(int(row['count']), 5)
self.env.assertGreater(int(row['count']), 2)
def testToList(self):
cmd = ['ft.aggregate', 'games', '*',
'GROUPBY', '1', '@brand',
'REDUCE', 'count_distinct', '1', '@price', 'as', 'count',
'REDUCE', 'tolist', 1, '@price', 'as', 'prices',
'SORTBY', 2, '@count', 'desc',
'LIMIT', '0', '5'
]
res = self.env.cmd(*cmd)
for row in res[1:]:
row = to_dict(row)
self.env.assertEqual(int(row['count']), len(row['prices']))
def testSortBy(self):
res = self.env.cmd('ft.aggregate', 'games', '*', 'GROUPBY', '1', '@brand',
'REDUCE', 'sum', 1, '@price', 'as', 'price',
'SORTBY', 2, '@price', 'desc',
'LIMIT', '0', '2')
self.env.assertListEqual([292L, ['brand', '', 'price', '44780.69'], [
'brand', 'mad catz', 'price', '3973.48']], res)
res = self.env.cmd('ft.aggregate', 'games', '*', 'GROUPBY', '1', '@brand',
'REDUCE', 'sum', 1, '@price', 'as', 'price',
'SORTBY', 2, '@price', 'asc',
'LIMIT', '0', '2')
self.env.assertListEqual([292L, ['brand', 'myiico', 'price', '0.23'], [
'brand', 'crystal dynamics', 'price', '0.25']], res)
# Test MAX with limit higher than it
res = self.env.cmd('ft.aggregate', 'games', '*', 'GROUPBY', '1', '@brand',
'REDUCE', 'sum', 1, '@price', 'as', 'price',
'SORTBY', 2, '@price', 'asc', 'MAX', 2)
self.env.assertListEqual([292L, ['brand', 'myiico', 'price', '0.23'], [
'brand', 'crystal dynamics', 'price', '0.25']], res)
# Test Sorting by multiple properties
res = self.env.cmd('ft.aggregate', 'games', '*', 'GROUPBY', '1', '@brand',
'REDUCE', 'sum', 1, '@price', 'as', 'price',
'APPLY', '(@price % 10)', 'AS', 'price',
'SORTBY', 4, '@price', 'asc', '@brand', 'desc', 'MAX', 10,
)
self.env.assertListEqual([292L, ['brand', 'zps', 'price', '0'], ['brand', 'zalman', 'price', '0'], ['brand', 'yoozoo', 'price', '0'], ['brand', 'white label', 'price', '0'], ['brand', 'stinky', 'price', '0'], [
'brand', 'polaroid', 'price', '0'], ['brand', 'plantronics', 'price', '0'], ['brand', 'ozone', 'price', '0'], ['brand', 'oooo', 'price', '0'], ['brand', 'neon', 'price', '0']], res)
def testExpressions(self):
pass
def testNoGroup(self):
res = self.env.cmd('ft.aggregate', 'games', '*', 'LOAD', '2', '@brand', '@price',
'APPLY', 'floor(sqrt(@price)) % 10', 'AS', 'price',
'SORTBY', 4, '@price', 'desc', '@brand', 'desc', 'MAX', 5,
)
exp = [2265L,
['brand', 'xbox', 'price', '9'],
['brand', 'turtle beach', 'price', '9'],
['brand', 'trust', 'price', '9'],
['brand', 'steelseries', 'price', '9'],
['brand', 'speedlink', 'price', '9']]
# exp = [2265L, ['brand', 'Xbox', 'price', '9'], ['brand', 'Turtle Beach', 'price', '9'], [
# 'brand', 'Trust', 'price', '9'], ['brand', 'SteelSeries', 'price', '9'], ['brand', 'Speedlink', 'price', '9']]
self.env.assertListEqual(exp[1], res[1])
def testLoad(self):
res = self.env.cmd('ft.aggregate', 'games', '*',
'LOAD', '3', '@brand', '@price', '@nonexist',
'SORTBY', 2, '@price', 'DESC', 'MAX', 2)
exp = [3L, ['brand', '', 'price', '759.12'], ['brand', 'Sony', 'price', '695.8']]
self.env.assertEqual(exp[1], res[1])
def testSplit(self):
res = self.env.cmd('ft.aggregate', 'games', '*', 'APPLY', 'split("hello world, foo,,,bar,", ",", " ")', 'AS', 'strs',
'APPLY', 'split("hello world, foo,,,bar,", " ", ",")', 'AS', 'strs2',
'APPLY', 'split("hello world, foo,,,bar,", "", "")', 'AS', 'strs3',
'APPLY', 'split("hello world, foo,,,bar,")', 'AS', 'strs4',
'APPLY', 'split("hello world, foo,,,bar,",",")', 'AS', 'strs5',
'APPLY', 'split("")', 'AS', 'empty',
'LIMIT', '0', '1'
)
# print "Got {} results".format(len(res))
# return
# pprint.pprint(res)
self.env.assertListEqual([1L, ['strs', ['hello world', 'foo', 'bar'],
'strs2', ['hello', 'world', 'foo,,,bar'],
'strs3', ['hello world, foo,,,bar,'],
'strs4', ['hello world', 'foo', 'bar'],
'strs5', ['hello world', 'foo', 'bar'],
'empty', []]], res)
def testFirstValue(self):
res = self.env.cmd('ft.aggregate', 'games', '@brand:(sony|matias|beyerdynamic|(mad catz))',
'GROUPBY', 1, '@brand',
'REDUCE', 'FIRST_VALUE', 4, '@title', 'BY', '@price', 'DESC', 'AS', 'top_item',
'REDUCE', 'FIRST_VALUE', 4, '@price', 'BY', '@price', 'DESC', 'AS', 'top_price',
'REDUCE', 'FIRST_VALUE', 4, '@title', 'BY', '@price', 'ASC', 'AS', 'bottom_item',
'REDUCE', 'FIRST_VALUE', 4, '@price', 'BY', '@price', 'ASC', 'AS', 'bottom_price',
'SORTBY', 2, '@top_price', 'DESC', 'MAX', 5
)
expected = [4L, ['brand', 'sony', 'top_item', 'sony psp slim & lite 2000 console', 'top_price', '695.8', 'bottom_item', 'sony dlchd20p high speed hdmi cable for playstation 3', 'bottom_price', '5.88'],
['brand', 'matias', 'top_item', 'matias halfkeyboard usb', 'top_price',
'559.99', 'bottom_item', 'matias halfkeyboard usb', 'bottom_price', '559.99'],
['brand', 'beyerdynamic', 'top_item', 'beyerdynamic mmx300 pc gaming premium digital headset with microphone', 'top_price', '359.74',
'bottom_item', 'beyerdynamic headzone pc gaming digital surround sound system with mmx300 digital headset with microphone', 'bottom_price', '0'],
['brand', 'mad catz', 'top_item', 'mad catz s.t.r.i.k.e.7 gaming keyboard', 'top_price', '295.95', 'bottom_item', 'madcatz mov4545 xbox replacement breakaway cable', 'bottom_price', '3.49']]
self.env.assertListEqual(expected, res)
def testLoadAfterGroupBy(self):
with self.env.assertResponseError():
self.env.cmd('ft.aggregate', 'games', '*',
'GROUPBY', 1, '@brand',
'LOAD', 1, '@brand')
