def testDependenciesBasicExportImport():
env = Env(moduleArgs='CreateVenv 1')
conn = getConnectionByEnv(env)
#disable rdb save
res, err = env.cmd(
'RG.PYEXECUTE',
"GB('ShardsIDReader').foreach(lambda x: execute('config', 'set', 'save', '')).run()"
)
env.expect('RG.PYEXECUTE', "import redisgraph", 'REQUIREMENTS',
'redisgraph').ok()
md, data = env.cmd('RG.PYEXPORTREQ', 'redisgraph')
env.assertEqual(md[5], 'yes')
env.assertEqual(md[7], 'yes')
env.stop()
env.start()
conn = getConnectionByEnv(env)
env.expect('RG.PYDUMPREQS').equal([])
env.expect('RG.PYIMPORTREQ', *data).equal('OK')
res, err = env.cmd(
'RG.PYEXECUTE',
"GB('ShardsIDReader').flatmap(lambda x: execute('RG.PYDUMPREQS')).run()"
)
env.assertEqual(len(err), 0)
env.assertEqual(len(res), env.shardsCount)
for r in res:
env.assertContains("'IsDownloaded', 'yes', 'IsInstalled', 'yes'", r)
def testCompressionConfig(env):
env.skipOnCluster()
conn = getConnectionByEnv(env)
env.cmd('ft.create', 'idx', 'SCHEMA', 'n', 'numeric')
# w/o compression. exact number match.
env.expect('ft.config', 'set', '_NUMERIC_COMPRESS', 'false').equal('OK')
for i in range(100):
env.execute_command('hset', i, 'n', str(1 + i / 100.0))
for i in range(100):
num = str(1 + i / 100.0)
env.expect('ft.search', 'idx',
'@n:[%s %s]' % (num, num)).equal([1L,
str(i), ['n', num]])
# with compression. no exact number match.
env.expect('ft.config', 'set', '_NUMERIC_COMPRESS', 'true').equal('OK')
for i in range(100):
env.execute_command('hset', i, 'n', str(1 + i / 100.0))
# delete keys where compression does not change value
env.execute_command('del', '0')
env.execute_command('del', '25')
env.execute_command('del', '50')
env.execute_command('del', '75')
for i in range(100):
num = str(1 + i / 100.0)
env.expect('ft.search', 'idx', '@n:[%s %s]' % (num, num)).equal([0L])
def testAof(env):
env = Env(moduleArgs='CreateVenv 1', useAof=True)
conn = getConnectionByEnv(env)
env.expect('RG.PYEXECUTE', "import redisgraph", 'REQUIREMENTS',
'redisgraph').ok()
res, err = env.cmd(
'RG.PYEXECUTE',
"GB('ShardsIDReader').flatmap(lambda x: execute('RG.PYDUMPREQS')).run()"
)
env.assertEqual(len(err), 0)
env.assertEqual(len(res), env.shardsCount)
for r in res:
env.assertContains("'IsDownloaded', 'yes', 'IsInstalled', 'yes'", r)
env.broadcast('debug', 'loadaof')
res, err = env.cmd(
'RG.PYEXECUTE',
"GB('ShardsIDReader').flatmap(lambda x: execute('RG.PYDUMPREQS')).run()"
)
env.assertEqual(len(err), 0)
env.assertEqual(len(res), env.shardsCount)
for r in res:
env.assertContains("'IsDownloaded', 'yes', 'IsInstalled', 'yes'", r)
def testBasicStreamProcessing(env):
conn = getConnectionByEnv(env)
res = env.cmd(
'rg.pyexecute', "GearsBuilder('StreamReader')."
"flatmap(lambda x: [(a[0], a[1]) for a in x['value'].items()])."
"repartition(lambda x: x[0])."
"foreach(lambda x: redisgears.executeCommand('set', x[0], x[1]))."
"map(lambda x: str(x))."
"register('stream1')", 'UNBLOCKING')
env.assertEqual(res, 'OK')
if (res != 'OK'):
return
time.sleep(0.5) # make sure the registration reached to all shards
env.cmd('XADD', 'stream1', '*', 'f1', 'v1', 'f2', 'v2')
res = []
while len(res) < 1:
res = env.cmd('rg.dumpexecutions')
for e in res:
env.broadcast('rg.getresultsblocking', e[1])
env.cmd('rg.dropexecution', e[1])
env.assertEqual(conn.get('f1'), 'v1')
env.assertEqual(conn.get('f2'), 'v2')
# delete all registrations and executions so valgrind check will pass
executions = env.cmd('RG.DUMPEXECUTIONS')
for r in executions:
env.expect('RG.DROPEXECUTION', r[1]).equal('OK')
registrations = env.cmd('RG.DUMPREGISTRATIONS')
for r in registrations:
env.expect('RG.UNREGISTER', r[1]).equal('OK')
def test_1667(env):
conn = getConnectionByEnv(env)
conn.execute_command('FT.CREATE', 'idx', 'SCHEMA', 'tag', 'TAG', 'text', 'TEXT')
env.expect('ft.search idx @tag:{a}').equal([0L])
env.expect('ft.search idx @tag:{b}').equal([0L])
conn.execute_command('HSET', 'doc', 'tag', 'a,b')
conn.execute_command('HSET', 'doc1', 'tag', 'abc')
# test single stopword
env.expect('ft.search idx @tag:{a}').equal([1L, 'doc', ['tag', 'a,b']])
env.expect('ft.search idx @tag:{b}').equal([1L, 'doc', ['tag', 'a,b']])
env.expect('ft.search idx @tag:{c}').equal([0L])
# test stopword in list
env.expect('ft.search idx @tag:{a|c}').equal([1L, 'doc', ['tag', 'a,b']])
env.expect('ft.search idx @tag:{c|a}').equal([1L, 'doc', ['tag', 'a,b']])
env.expect('ft.search idx @tag:{c|a|c}').equal([1L, 'doc', ['tag', 'a,b']])
# test stopword with prefix
env.expect('ft.search idx @tag:{ab*}').equal([1L, 'doc1', ['tag', 'abc']])
env.expect('ft.search idx @tag:{abc*}').equal([1L, 'doc1', ['tag', 'abc']])
# ensure regular text field
conn.execute_command('HSET', 'doc_a', 'text', 'a')
conn.execute_command('HSET', 'doc_b', 'text', 'b')
env.expect('ft.search idx a').equal([0L])
env.expect('ft.search idx b').equal([1L, 'doc_b', ['text', 'b']])
def testReplace(env):
conn = getConnectionByEnv(env)
r = env
r.expect('ft.create idx schema f text').ok()
res = conn.execute_command('HSET', 'doc1', 'f', 'hello world')
env.assertEqual(res, 1)
res = conn.execute_command('HSET', 'doc2', 'f', 'hello world')
env.assertEqual(res, 1)
res = r.execute_command('ft.search', 'idx', 'hello world')
r.assertEqual(2, res[0])
# now replace doc1 with a different content
res = conn.execute_command('HSET', 'doc1', 'f', 'goodbye universe')
env.assertEqual(res, 0)
for _ in r.retry_with_rdb_reload():
waitForIndex(env, 'idx')
# make sure the query for hello world does not return the replaced document
r.expect('ft.search', 'idx', 'hello world',
'nocontent').equal([1, 'doc2'])
# search for the doc's new content
r.expect('ft.search', 'idx', 'goodbye universe',
'nocontent').equal([1, 'doc1'])
def test_issue1834(env):
# Stopword query is case sensitive.
conn = getConnectionByEnv(env)
conn.execute_command('FT.CREATE', 'idx', 'SCHEMA', 't', 'TEXT')
conn.execute_command('HSET', 'doc', 't', 'hell hello')
env.expect('FT.SEARCH', 'idx', 'hell|hello', 'HIGHLIGHT').equal([1L, 'doc', ['t', '<b>hell</b> <b>hello</b>']])
def aofTestCommon(env, reloadfn):
# TODO: Change this attribute in rmtest
conn = getConnectionByEnv(env)
env.cmd('ft.create', 'idx', 'ON', 'HASH', 'schema', 'field1', 'text',
'field2', 'numeric')
for x in range(1, 10):
conn.execute_command('hset', 'doc{}'.format(x), 'field1',
'myText{}'.format(x), 'field2', 20 * x)
reloadfn()
waitForIndex(env, 'idx')
exp = [
9L, 'doc1', ['field1', 'myText1', 'field2', '20'], 'doc2',
['field1', 'myText2', 'field2', '40'], 'doc3',
['field1', 'myText3', 'field2', '60'], 'doc4',
['field1', 'myText4', 'field2', '80'], 'doc5',
['field1', 'myText5', 'field2', '100'], 'doc6',
['field1', 'myText6', 'field2', '120'], 'doc7',
['field1', 'myText7', 'field2', '140'], 'doc8',
['field1', 'myText8', 'field2', '160'], 'doc9',
['field1', 'myText9', 'field2', '180']
]
reloadfn()
waitForIndex(env, 'idx')
ret = env.cmd('ft.search', 'idx', 'myt*')
env.assertEqual(toSortedFlatList(ret), toSortedFlatList(exp))
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 testProfileOutput(env):
env.skip()
docs = 10000
copies = 10
queries = 0
conn = getConnectionByEnv(env)
pl = conn.pipeline()
env.cmd('FT.CONFIG', 'SET', 'MAXPREFIXEXPANSIONS', 1000000)
env.cmd('FT.CONFIG', 'SET', '_PRINT_PROFILE_CLOCK', 'false')
env.cmd('FT.CONFIG', 'SET', 'UNION_ITERATOR_HEAP', 1)
env.cmd('ft.create', 'idx', 'SCHEMA', 't', 'text')
for i in range(docs):
pl.execute_command('hset', i, 't', str(i / copies), 'hello', string1,
'world', string2)
if (i % 999) is 0:
pl.execute()
pl.execute()
print "finished loading"
search_string = '12*|87*|42*'
#search_string = '(4|5) (5|6)'
#search_string = '1(1(1(1(1(1(1))))))'
#search_string = '1(1(1(1(1))))'
#print env.cmd('FT.search', 'idx', '12*|69*', 'limit', 0, 0)
for i in range(queries):
pl.execute_command('FT.PROFILE', 'search', 'idx', search_string,
'limit', 0, 1000)
if (i % 999) is 0:
pl.execute()
pl.execute()
res = env.cmd('FT.PROFILE', 'search', 'idx', search_string, 'limit', 0, 0,
'nocontent')
print res
def testProfileNumeric(env):
env.skipOnCluster()
conn = getConnectionByEnv(env)
env.cmd('FT.CONFIG', 'SET', '_PRINT_PROFILE_CLOCK', 'false')
env.cmd('ft.create', 'idx', 'SCHEMA', 'n', 'numeric')
conn.execute_command('hset', '1', 'n', '1.2')
conn.execute_command('hset', '2', 'n', '1.5')
conn.execute_command('hset', '3', 'n', '8.2')
conn.execute_command('hset', '4', 'n', '6.7')
conn.execute_command('hset', '5', 'n', '-14')
actual_res = conn.execute_command('ft.profile', 'idx', 'search', 'query',
'@n:[0,100]', 'nocontent')
expected_res = [
'Iterators profile',
[
'Type', 'UNION', 'Query type', 'NUMERIC', 'Counter', 4L,
'Children iterators',
[
'Type', 'NUMERIC', 'Term', '-14 - 1.35', 'Counter', 1L, 'Size',
2L
],
[
'Type', 'NUMERIC', 'Term', '1.35 - 8.2', 'Counter', 3L, 'Size',
3L
]
]
]
env.assertEqual(actual_res[1][3], expected_res)
def testProfileNumeric(env):
env.skipOnCluster()
conn = getConnectionByEnv(env)
env.cmd('FT.CONFIG', 'SET', 'MAXPREFIXEXPANSIONS', 1000000)
env.cmd('FT.CONFIG', 'SET', '_PRINT_PROFILE_CLOCK', 'false')
env.cmd('ft.create', 'idx', 'SCHEMA', 'n', 'numeric')
conn.execute_command('hset', '1', 'n', '1.2')
conn.execute_command('hset', '2', 'n', '1.5')
conn.execute_command('hset', '3', 'n', '8.2')
conn.execute_command('hset', '4', 'n', '6.7')
conn.execute_command('hset', '5', 'n', '-14')
actual_res = conn.execute_command('ft.profile', 'search', 'idx',
'@n:[0,100]', 'nocontent')
expected_res = [[4L, '1', '2', '3', '4'],
[['Total profile time'],
['Parsing and iterator creation time'],
[
'Iterators profile',
[
'Union iterator - NUMERIC', 5L,
['Numeric reader', '-14 - 1.35', 2L],
['Numeric reader', '1.35 - 8.2', 4L]
]
],
[
'Result processors profile', ['Index', 5L],
['Scorer', 5L], ['Sorter', 5L]
]]]
env.assertEqual(actual_res, expected_res)
def test_issue1880(env):
# order of iterator in intersect is optimized by function
env.skipOnCluster()
conn = getConnectionByEnv(env)
env.cmd('FT.CONFIG', 'SET', '_PRINT_PROFILE_CLOCK', 'false')
conn.execute_command('FT.CREATE', 'idx', 'SCHEMA', 't', 'TEXT')
conn.execute_command('HSET', 'doc1', 't', 'hello world')
conn.execute_command('HSET', 'doc2', 't', 'hello')
excepted_res = ['Type', 'INTERSECT', 'Counter', 1L, 'Children iterators',
['Type', 'TEXT', 'Term', 'world', 'Counter', 1L, 'Size', 1L],
['Type', 'TEXT', 'Term', 'hello', 'Counter', 1L, 'Size', 2L]]
res1 = env.cmd('FT.PROFILE', 'idx', 'SEARCH', 'QUERY', 'hello world')
res2 = env.cmd('FT.PROFILE', 'idx', 'SEARCH', 'QUERY', 'world hello')
# both queries return `world` iterator before `hello`
env.assertEqual(res1[1][3][1], excepted_res)
env.assertEqual(res2[1][3][1], excepted_res)
# test with a term which does not exist
excepted_res = ['Type', 'INTERSECT', 'Counter', 0L, 'Children iterators',
None,
['Type', 'TEXT', 'Term', 'world', 'Counter', 0L, 'Size', 1L],
['Type', 'TEXT', 'Term', 'hello', 'Counter', 0L, 'Size', 2L]]
res3 = env.cmd('FT.PROFILE', 'idx', 'SEARCH', 'QUERY', 'hello new world')
env.assertEqual(res3[1][3][1], excepted_res)
def testCommandOverrideHset(env):
conn = getConnectionByEnv(env)
script = '''
import time
def doHset(x):
x += ['__time', time.time()]
return call_next(*x[1:])
GB("CommandReader").map(doHset).register(hook="hset", mode="sync")
'''
env.expect('rg.pyexecute', script).ok()
verifyRegistrationIntegrity(env)
conn.execute_command('hset', 'h1', 'foo', 'bar')
conn.execute_command('hset', 'h2', 'foo', 'bar')
conn.execute_command('hset', 'h3', 'foo', 'bar')
res = conn.execute_command('hget', 'h1', '__time')
env.assertNotEqual(res, None)
res = conn.execute_command('hget', 'h2', '__time')
env.assertNotEqual(res, None)
res = conn.execute_command('hget', 'h3', '__time')
env.assertNotEqual(res, None)
def testRegistersOnPrefix(env):
conn = getConnectionByEnv(env)
env.cmd(
'rg.pyexecute', "GB()."
"filter(lambda x: x['type'] != 'empty')."
"map(lambda x: ('pref2:' + x['key'].split(':')[1], x['value']))."
"repartition(lambda x: x[0])."
"foreach(lambda x: execute('set', x[0], x[1]))."
"register(regex='pref1:*')")
time.sleep(0.1) ## wait for registration to get to all shards
conn.set('pref1:x', '1')
conn.set('pref1:y', '2')
conn.set('pref1:z', '3')
res = []
while len(res) < 3:
res = env.cmd('rg.dumpexecutions')
res = [r for r in res if r[3] == 'done']
env.assertEqual(conn.get('pref2:x'), '1')
env.assertEqual(conn.get('pref2:y'), '2')
env.assertEqual(conn.get('pref2:z'), '3')
executions = env.cmd('RG.DUMPEXECUTIONS')
for r in executions:
env.expect('RG.DROPEXECUTION', r[1]).equal('OK')
registrations = env.cmd('RG.DUMPREGISTRATIONS')
for r in registrations:
env.expect('RG.UNREGISTER', r[1]).equal('OK')
def testNotExist(env):
conn = getConnectionByEnv(env)
env.cmd('ft.create', 'things', 'ON', 'HASH', 'PREFIX', '1', 'thing:',
'FILTER', 'startswith(@__key, "thing:")', 'SCHEMA', 'txt', 'text')
conn.execute_command('hset', 'thing:bar', 'not_text', 'foo')
env.expect('ft.search', 'things', 'foo').equal([0L])
def testBasicStream(env):
conn = getConnectionByEnv(env)
res = env.cmd(
'rg.pyexecute', "GearsBuilder()."
"filter(lambda x:x['key'] != 'values' and x['type'] != 'empty')."
"repartition(lambda x: 'values')."
"foreach(lambda x: redisgears.executeCommand('lpush', 'values', x['value']))."
"register('*')", 'UNBLOCKING')
env.assertEqual(res, 'OK')
if (res != 'OK'):
return
time.sleep(0.5) # make sure the execution reached to all shards
conn.execute_command('set', 'x', '1')
conn.execute_command('set', 'y', '2')
conn.execute_command('set', 'z', '3')
res = []
while len(res) < 6:
res = env.cmd('rg.dumpexecutions')
for e in res:
env.broadcast('rg.getresultsblocking', e[1])
env.cmd('rg.dropexecution', e[1])
env.assertEqual(set(conn.lrange('values', '0', '-1')), set(['1', '2',
'3']))
# delete all registrations so valgrind check will pass
registrations = env.cmd('RG.DUMPREGISTRATIONS')
for r in registrations:
env.expect('RG.UNREGISTER', r[1]).equal('OK')
def testRegistersSurviveRestart(env):
conn = getConnectionByEnv(env)
env.cmd('rg.pyexecute', "GB().filter(lambda x: 'NumOfKeys' not in x['key'])."
"foreach(lambda x: execute('incrby', 'NumOfKeys{%s}' % (hashtag()), ('1' if 'value' in x.keys() else '-1')))."
"register(mode='async_local')")
time.sleep(0.1) # wait for execution to reach all the shards
for _ in env.reloading_iterator():
for i in range(100):
conn.set(str(i), str(i))
for i in range(100):
conn.delete(str(i))
# wait for all executions to finish
res = 0
while res < 200:
res = env.cmd('rg.pyexecute', "GB('ShardsIDReader').map(lambda x: len([r for r in execute('rg.dumpexecutions') if r[3] == 'done'])).aggregate(0, lambda a, x: x, lambda a, x: a + x).run()")
numOfKeys = env.cmd('rg.pyexecute', "GB().map(lambda x: int(x['value'])).aggregate(0, lambda a, x: x, lambda a, x: a + x).run('NumOfKeys*')")[0][0]
env.assertEqual(numOfKeys, '0')
# deleting all executions from all the shards, execution list are not identical so we use gears to clear it.
res = env.cmd('rg.pyexecute', "GB('ShardsIDReader').flatmap(lambda x: [r[1] for r in execute('rg.dumpexecutions')]).foreach(lambda x: execute('RG.DROPEXECUTION', x)).run()")
registrations = env.cmd('RG.DUMPREGISTRATIONS')
for r in registrations:
env.expect('RG.UNREGISTER', r[1]).equal('OK')
def testIssue1571WithRename(env):
conn = getConnectionByEnv(env)
env.cmd('ft.create', 'idx1', 'PREFIX', '1', 'idx1', 'FILTER',
'@index=="yes"', 'SCHEMA', 't', 'TEXT')
env.cmd('ft.create', 'idx2', 'PREFIX', '1', 'idx2', 'FILTER',
'@index=="yes"', 'SCHEMA', 't', 'TEXT')
conn.execute_command('hset', 'idx1:{doc}1', 't', 'foo1', 'index', 'yes')
env.expect('ft.search', 'idx1', 'foo*').equal(
[1L, 'idx1:{doc}1', ['t', 'foo1', 'index', 'yes']])
env.expect('ft.search', 'idx2', 'foo*').equal([0L])
conn.execute_command('rename', 'idx1:{doc}1', 'idx2:{doc}1')
env.expect('ft.search', 'idx2', 'foo*').equal(
[1L, 'idx2:{doc}1', ['t', 'foo1', 'index', 'yes']])
env.expect('ft.search', 'idx1', 'foo*').equal([0L])
conn.execute_command('hset', 'idx2:{doc}1', 'index', 'no')
env.expect('ft.search', 'idx1', 'foo*').equal([0L])
env.expect('ft.search', 'idx2', 'foo*').equal([0L])
conn.execute_command('rename', 'idx2:{doc}1', 'idx1:{doc}1')
env.expect('ft.search', 'idx1', 'foo*').equal([0L])
env.expect('ft.search', 'idx2', 'foo*').equal([0L])
conn.execute_command('hset', 'idx1:{doc}1', 'index', 'yes')
env.expect('ft.search', 'idx1', 'foo*').equal(
[1L, 'idx1:{doc}1', ['t', 'foo1', 'index', 'yes']])
env.expect('ft.search', 'idx2', 'foo*').equal([0L])
def testNotIterator(env):
env.skipOnCluster()
conn = getConnectionByEnv(env)
env.cmd('FT.CONFIG', 'SET', 'MAXPREFIXEXPANSIONS', 2)
env.cmd('FT.CONFIG', 'SET', '_PRINT_PROFILE_CLOCK', 'false')
conn.execute_command('FT.CREATE', 'idx', 'SCHEMA', 't', 'text')
conn.execute_command('HSET', '1', 't', 'foo')
conn.execute_command('HSET', '2', 't', 'bar')
#before the fix, we would not get an empty iterator
res = [[1, '1', ['t', 'foo']],
[['Total profile time'], ['Parsing time'],
['Pipeline creation time'],
[
'Iterators profile',
[
'Type', 'INTERSECT', 'Counter', 1, 'Child iterators',
['Type', 'TEXT', 'Term', 'foo', 'Counter', 1, 'Size', 1],
[
'Type', 'NOT', 'Counter', 1, 'Child iterator',
['Type', 'EMPTY', 'Counter', 0]
]
]
],
[
'Result processors profile', ['Type', 'Index', 'Counter', 1],
['Type', 'Scorer', 'Counter', 1],
['Type', 'Sorter', 'Counter', 1],
['Type', 'Loader', 'Counter', 1]
]]]
env.expect('ft.profile', 'idx', 'search', 'query',
'foo -@t:baz').equal(res)
def testProfileAggregate(env):
env.skipOnCluster()
conn = getConnectionByEnv(env)
env.cmd('FT.CONFIG', 'SET', '_PRINT_PROFILE_CLOCK', 'false')
env.cmd('ft.create', 'idx', 'SCHEMA', 't', 'text')
conn.execute_command('hset', '1', 't', 'hello')
conn.execute_command('hset', '2', 't', 'world')
expected_res = [
'Result processors profile', ['Type', 'Index', 'Counter', 1],
['Type', 'Loader', 'Counter', 1], ['Type', 'Grouper', 'Counter', 1]
]
actual_res = conn.execute_command('ft.profile', 'idx', 'aggregate',
'query', 'hello', 'groupby', 1, '@t',
'REDUCE', 'count', '0', 'as', 'sum')
env.assertEqual(actual_res[1][4], expected_res)
expected_res = [
'Result processors profile', ['Type', 'Index', 'Counter', 2],
['Type', 'Loader', 'Counter', 2],
['Type', 'Projector - Function startswith', 'Counter', 2]
]
actual_res = env.cmd('ft.profile', 'idx', 'aggregate', 'query', '*',
'load', 1, 't', 'apply', 'startswith(@t, "hel")',
'as', 'prefix')
env.assertEqual(actual_res[1][4], expected_res)
def testProfileSearchLimited(env):
env.skipOnCluster()
conn = getConnectionByEnv(env)
env.cmd('FT.CONFIG', 'SET', '_PRINT_PROFILE_CLOCK', 'false')
env.cmd('ft.create', 'idx', 'SCHEMA', 't', 'text')
conn.execute_command('hset', '1', 't', 'hello')
conn.execute_command('hset', '2', 't', 'hell')
conn.execute_command('hset', '3', 't', 'help')
conn.execute_command('hset', '4', 't', 'helowa')
actual_res = conn.execute_command('ft.profile', 'idx', 'search', 'limited',
'query', '%hell% hel*')
expected_res = [
'Iterators profile',
[
'Type', 'INTERSECT', 'Counter', 3, 'Child iterators',
[
'Type', 'UNION', 'Query type', 'FUZZY - hell', 'Counter', 3,
'Child iterators', 'The number of iterators in the union is 3'
],
[
'Type', 'UNION', 'Query type', 'PREFIX - hel', 'Counter', 3,
'Child iterators', 'The number of iterators in the union is 4'
]
]
]
env.assertEqual(actual_res[1][3], expected_res)
def testStreamReaderAsync(env):
env.skipOnCluster()
conn = getConnectionByEnv(env)
script = '''
fdata = []
class BlockHolder:
def __init__(self, bc):
self.bc = bc
def __getstate__(self):
state = dict(self.__dict__)
state['bc'] = None
return state
def continueRun(self, r):
if self.bc:
self.bc.continueRun(r)
def bc(r):
global fdata
f = BlockHolder(gearsFuture())
fd = (f, r)
fdata.insert(0, fd)
return f.bc
GB('CommandReader').map(lambda a: fdata.pop()).foreach(lambda x: x[0].continueRun(x[1])).register(trigger='unblock')
GB('StreamReader').map(bc).foreach(lambda x: execute('set', x['value']['key'], x['value']['val'])).register(mode='sync', prefix='s')
'''
env.expect('RG.PYEXECUTE', script).ok()
# this will make sure registrations reached all the shards
verifyRegistrationIntegrity(env)
env.cmd('xadd', 's', '*', 'key', 'x', 'val', '1')
env.cmd('xadd', 's', '*', 'key', 'y', 'val', '2')
env.cmd('xadd', 's', '*', 'key', 'z', 'val', '3')
try:
with TimeLimit(50):
env.cmd('RG.TRIGGER', 'unblock')
x = None
while x != '1':
x = env.cmd('get', 'x')
time.sleep(0.1)
env.cmd('RG.TRIGGER', 'unblock')
y = None
while y != '2':
y = env.cmd('get', 'y')
time.sleep(0.1)
env.cmd('RG.TRIGGER', 'unblock')
z = None
while z != '3':
z = env.cmd('get', 'z')
time.sleep(0.1)
except Exception as e:
env.assertTrue(False, message='Failed waiting to reach unblock')
def testSimpleAsyncOnFilter(env):
conn = getConnectionByEnv(env)
script = '''
fdata = []
class BlockHolder:
def __init__(self, bc):
self.bc = bc
def __getstate__(self):
state = dict(self.__dict__)
state['bc'] = None
return state
def continueRun(self, r):
if self.bc:
self.bc.continueRun(r)
def bc(r):
global fdata
f = BlockHolder(gearsFuture())
fdata.insert(0, f)
return f.bc
def unbc(r):
global fdata
try:
f = fdata.pop()
except Exception as e:
return 0
if f:
f.continueRun(True if r[1] == 'true' else False)
return 1
return 0
GB('CommandReader').flatmap(lambda x: execute('keys', '*')).collect().filter(bc).count().register(trigger='block')
GB('CommandReader').map(unbc).register(trigger='unblock')
'''
env.expect('RG.PYEXECUTE', script).ok()
# this will make sure registrations reached all the shards
verifyRegistrationIntegrity(env)
conn.execute_command('set', 'x', '1')
conn.execute_command('set', 'y', '2')
conn.execute_command('set', 'z', '3')
def Block():
env.expect('RG.TRIGGER', 'block').equal(['3'])
try:
with Background(Block) as bk:
with TimeLimit(50):
while bk.isAlive:
conn.execute_command('RG.TRIGGER', 'unblock', 'true')
time.sleep(0.1)
except Exception as e:
env.assertTrue(False, message='Failed waiting to reach unblock')
def testDependenciesImportSerializationError():
env = Env(moduleArgs='CreateVenv 1')
conn = getConnectionByEnv(env)
env.expect('RG.PYEXECUTE', "import rejson", 'REQUIREMENTS', 'rejson').ok()
md, data = env.cmd('RG.PYEXPORTREQ', 'rejson')
data = b''.join(data)
for i in range(len(data) - 1):
env.expect('RG.PYIMPORTREQ', data[:i]).error()
def testPrefix0a(env):
conn = getConnectionByEnv(env)
env.cmd('ft.create', 'things', 'ON', 'HASH',
'PREFIX', '1', '',
'SCHEMA', 'name', 'text')
conn.execute_command('hset', 'thing:bar', 'name', 'foo')
env.expect('ft.search', 'things', 'foo').equal([1L, 'thing:bar', ['name', 'foo']])
def test_issue1826(env):
# Stopword query is case sensitive.
conn = getConnectionByEnv(env)
conn.execute_command('FT.CREATE', 'idx', 'SCHEMA', 't', 'TEXT')
conn.execute_command('HSET', 'doc', 't', 'boy with glasses')
env.expect('FT.SEARCH', 'idx', 'boy with glasses').equal([1L, 'doc', ['t', 'boy with glasses']])
env.expect('FT.SEARCH', 'idx', 'boy With glasses').equal([1L, 'doc', ['t', 'boy with glasses']])
def test_1601(env):
conn = getConnectionByEnv(env)
conn.execute_command('FT.CREATE', 'idx:movie', 'SCHEMA', 'title', 'TEXT')
conn.execute_command('HSET', 'movie:1', 'title', 'Star Wars: Episode I - The Phantom Menace')
conn.execute_command('HSET', 'movie:2', 'title', 'Star Wars: Episodes II - Attack of the Clones')
conn.execute_command('HSET', 'movie:3', 'title', 'Star Wars: Episode III - Revenge of the Sith')
res = env.cmd('ft.search idx:movie @title:(episode) withscores nocontent')
env.assertEqual(res[0], 3L)
def testMaxAggResults(env):
if env.env == 'existing-env':
env.skip()
env = Env(moduleArgs="MAXAGGREGATERESULTS 100")
conn = getConnectionByEnv(env)
env.execute_command('ft.create', 'idx', 'SCHEMA', 't', 'TEXT')
env.expect('ft.aggregate', 'idx', '*', 'LIMIT', '0', '10000').error() \
.contains('LIMIT exceeds maximum of 100')
def testDependenciesInstallFailure():
env = Env(moduleArgs='CreateVenv 1')
conn = getConnectionByEnv(env)
env.expect(
'RG.PYEXECUTE', "GB('ShardsIDReader')."
"map(lambda x: __import__('redisgraph'))."
"collect().distinct().run()", 'REQUIREMENTS',
str(uuid.uuid4())).error().contains('satisfy requirements')
