tarantool 0.2.5 → 0.3.0.7

data/test/shared_space_array.rb

@@ -0,0 +1,284 @@
+require File.expand_path('../helper.rb', __FILE__)
+
+shared_examples_for :blocking_array_space do
+  before { clear_db }
+
+  let(:space0) { tarantool.space_array(0, SPACE0[:types], keys: SPACE0[:keys])}
+  let(:space1) { tarantool.space_array(1, SPACE1[:types], keys: SPACE1[:keys])}
+  let(:space2) { tarantool.space_array(2, SPACE2[:types], keys: SPACE2[:keys])}
+  let(:space3) { tarantool.space_array(3, SPACE3[:types], keys: SPACE3[:keys])}
+
+  describe "with definition" do
+    let(:vasya){ ['vasya', 'petrov', 'eb@lo.com', 5] }
+    let(:ilya) { ['ilya', 'zimov', 'il@zi.bot', 13] }
+    let(:fedor){ ['fedor', 'kuklin', 'ku@kl.in', 13] }
+    it "should be selectable" do
+      results = blockrun { [
+        space0.select(0, 'vasya'),
+        space0.select(0, ['vasya']),
+        space0.select(0, ['vasya', 'ilya']),
+        space0.select(0, [['vasya'], ['ilya']]),
+        space0.select(0, [['ilya'], ['vasya']]),
+        space0.select(0, [['ilya'], ['vasya']], 0, 1),
+        space0.select(0, [['ilya'], ['vasya']], 1, 1),
+        space0.select(2, 13, 0, 2),
+        space0.select(1, [['zimov','il@zi.bot']])
+      ] }
+      results[0].must_equal [vasya]
+      results[1].must_equal [vasya]
+      results[2].must_equal [vasya, ilya]
+      results[3].must_equal [vasya, ilya]
+      results[4].must_equal [ilya, vasya]
+      results[5].must_equal [ilya]
+      results[6].must_equal [vasya]
+      (results[7] - [ilya, fedor]).must_be_empty
+      ([ilya, fedor] - results[7]).must_be_empty
+      results[8].must_equal [ilya]
+    end
+
+    it "should be able to all_by_keys" do
+      results = blockrun { [
+        space0.all_by_keys(0, 'vasya'),
+        space0.all_by_keys(0, ['vasya']),
+        space0.all_by_keys(0, ['vasya', 'ilya']),
+        space0.all_by_keys(0, [['vasya'], ['ilya']]),
+        space0.all_by_keys(0, [['ilya'], ['vasya']]),
+        space0.all_by_keys(0, [['ilya'], ['vasya']], limit: 1),
+        space0.all_by_keys(0, [['ilya'], ['vasya']], limit: 1, offset: 1),
+        space0.all_by_keys(2, 13),
+        space0.all_by_keys(1, [['zimov','il@zi.bot']]),
+      ] }
+      results[0].must_equal [vasya]
+      results[1].must_equal [vasya]
+      results[2].must_equal [vasya, ilya]
+      results[3].must_equal [vasya, ilya]
+      results[4].must_equal [ilya, vasya]
+      results[5].must_equal [ilya]
+      results[6].must_equal [vasya]
+      (results[7] - [ilya, fedor]).must_be_empty
+      results[8].must_equal [ilya]
+    end
+
+    it "should be able to all_by_key" do
+      results = blockrun { [
+        space0.all_by_key(0, 'vasya'),
+        space0.all_by_key(0, ['vasya']),
+        space0.all_by_key(2, 13),
+        space0.all_by_key(1, ['zimov','il@zi.bot']),
+      ] }
+      results[0].must_equal [vasya]
+      results[1].must_equal [vasya]
+      (results[2] - [ilya, fedor]).must_be_empty
+      results[3].must_equal [ilya]
+    end
+
+    it "should be able to first_by_key" do
+      results = blockrun { [
+        space0.first_by_key(0, 'vasya'),
+        space0.first_by_key(0, ['ilya']),
+        space0.first_by_key(2, 13),
+        space0.first_by_key(1, ['petrov','eb@lo.com']),
+      ] }
+      results[0].must_equal vasya
+      results[1].must_equal ilya
+      [ilya, fedor].must_include results[2]
+      results[3].must_equal vasya
+    end
+
+    it "should be able to by_pk" do
+      results = blockrun { [
+        space0.by_pk('vasya'),
+        space0.by_pk(['ilya']),
+        space2.by_pk(['hi zo', 'ho zo']),
+      ] }
+      results[0].must_equal vasya
+      results[1].must_equal ilya
+      results[2].must_equal ['hi zo', 'ho zo', 1]
+    end
+    
+    it "should raise on not matched pk" do
+      proc {
+        space0.by_pk(['il','ya'])
+      }.must_raise Tarantool::ArgumentError
+    end
+
+    it "should fetch longer records" do
+      results = blockrun { [
+        space2.by_pk(['hi zo', 'pidas']),
+        space1.by_pk(2),
+      ]}
+      results[0].must_equal ['hi zo', 'pidas', 1, 3, 5]
+      results[1].must_equal [2, 'medium', 6, 'common', 7]
+    end
+
+    it "should be able to insert" do
+      asdf = ['asdf', 'asdf', 'asdf', 4, 5]
+      qwer = ['qwer', 'qwer', 'qwer', 4, 20, 19]
+      zxcv = [4, 'zxcv', 7, 'zxcv', 8]
+      xcvb = [5, 'xcvb', 7, 'xcvb', 8]
+      results = blockrun {[
+        space0.insert(asdf),
+        space0.insert(qwer, return_tuple: true),
+        space1.insert(zxcv),
+        space1.by_pk(4),
+        space1.insert(xcvb, return_tuple: true),
+      ]}
+      results[0].must_equal 1
+      results[1].must_equal qwer
+      results[2].must_equal 1
+      results[3].must_equal zxcv
+      results[4].must_equal xcvb
+    end
+
+    it "should be able to update" do
+      results = blockrun {[
+        space0.update('vasya', {1 => 'holodov', 3 => [:+, 2]}, return_tuple: true),
+        space0.update('ilya', {[2, :set] => 'we@al.hero', 3 => [:&, 7]}, return_tuple: true),
+        space1.update(2, [[2, :^, 3], [4, :|, 20]]),
+        space1.by_pk(2),
+        space1.update(1, [1, :splice, 2, 2, 'nd'], return_tuple: true),
+        space2.update(['hi zo', 'pidas'], [[2, :delete], [3, :delete]], return_tuple: true),
+        space2.update(['coma', 'peredoma'], [2, :insert, 1]),
+        space2.all_by_key(1, 1),
+      ]}
+      results[0].must_equal ['vasya', 'holodov', 'eb@lo.com', 7]
+      results[1].must_equal ['ilya', 'zimov', 'we@al.hero', 5]
+      results[2].must_equal 1
+      results[3].must_equal [2, 'medium', 5, 'common', 23]
+      results[4].must_equal [1, 'condon', 4]
+      results[5].must_equal ['hi zo', 'pidas', 5]
+      results[6].must_equal 1
+      res = [['hi zo', 'ho zo', 1], ['coma', 'peredoma', 1, 2]]
+      results[7].sort.must_equal res.sort
+    end
+
+    it "should be able to update (2)" do
+      results = blockrun {[
+        space2.update(['hi zo', 'pidas'], [[3, [:+, 1]], [4, [:+, -1]]], return_tuple: true)
+      ]}
+      results[0].must_equal ['hi zo', 'pidas', 1, 4, 4]
+    end
+
+    it "should be able to delete" do
+      results = blockrun {[
+        space0.delete('vasya', return_tuple: true),
+        space1.delete([1], return_tuple: true),
+        space2.delete(['hi zo', 'pidas'], return_tuple: true),
+      ]}
+      results[0].must_equal vasya
+      results[1].must_equal [1, 'common', 4]
+      results[2].must_equal ['hi zo', 'pidas', 1, 3, 5]
+    end
+
+    it "should be able to choose index by field numbers" do
+      results = blockrun {[
+        space0.first_by_key([0], 'vasya'),
+        space0.first_by_key([1,2], ['zimov', 'il@zi.bot']),
+        space0.all_by_key([3], 13),
+        space2.first_by_key([1,0], ['peredoma', 'coma']),
+      ]}
+      results[0].must_equal vasya
+      results[1].must_equal ilya
+      (results[2] - [ilya, fedor]).must_be_empty
+      ([ilya, fedor] - results[2]).must_be_empty
+      results[3].must_equal ['coma', 'peredoma', 2]
+    end
+
+    it "should be able to invoke" do
+      results = blockrun {[
+        space0.invoke('truncate'),
+        space0.by_pk('vasya'),
+        space0.by_pk('ilya')
+      ]}
+      results.must_equal [0, nil, nil]
+    end
+
+    it "should be able to call" do
+      results = blockrun {[
+        space0.call('truncate'),
+        space0.by_pk('vasya'),
+        space0.by_pk('ilya')
+      ]}
+      results.must_equal [[], nil, nil]
+    end
+
+    it "should be able to call (1)" do
+      results = blockrun {[
+        space0.call('func1'),
+        space0.call('func1', [1, 2]),
+        space0.call('func1', ['1', '2']),
+        space0.call('func1', [1, 2], types: [:int, :int]),
+        space0.call('func2', [1, 2], types: [:int, :int], returns: [:str, :int])
+      ]}
+      results.must_equal [
+        [['string', '0'], ['nil'], ['nil']], 
+        [['string', '0'], ['string', '1'], ['string', '2']],
+        [['string', '0'], ['string', '1'], ['string', '2']],
+        [['string', '0'], ['string', "\x01\x00\x00\x00"], ['string', "\x02\x00\x00\x00"]],
+        [['string', 1], ['string', 2]],
+      ]
+    end
+
+    it "should be able to call (2)" do
+      results = blockrun {[
+        space0.call('box.select_range', [0, 2]),
+        space0.call('box.select_range', [0, 1000000, 'ilya'])
+      ]} 
+      results[0].must_equal [fedor, ilya]
+      results[1].must_equal [ilya, vasya]
+    end
+
+    describe "Array Serializer" do
+      it "should be able to save" do
+        results = blockrun {[
+          space3.insert([1, [1,2,3,4]], return_tuple: true),
+          space3.insert([2, []], return_tuple: true),
+          space3.insert([3, nil], return_tuple: true),
+          space3.all_by_pks([1,2,3])
+        ]}
+        results[0].must_equal [1, [1,2,3,4]]
+        results[1].must_equal [2, nil]
+        results[2].must_equal [3, nil]
+        results[3].sort.must_equal [[1, [1,2,3,4]], [2, nil], [3, nil]]
+      end
+      
+      it "should be able to update" do
+        results = blockrun {[
+          space3.insert([1, [1,2,3,4]], return_tuple: true),
+          space3.update(1, [1, :set, [4,3,2,1]], return_tuple: true)
+        ]}
+        results.must_equal [[1, [1,2,3,4]], [1,[4,3,2,1]]]
+      end
+
+      it "should be able to save tail with same type" do
+        results = blockrun {[
+          space3.insert([1, [1,2,3,4], [4,3,2,1], [2,1]], return_tuple: true),
+          space3.by_pk(1)
+        ]}
+        results[0].must_equal [1, [1,2,3,4], [4,3,2,1], [2,1]]
+        results[1].must_equal [1, [1,2,3,4], [4,3,2,1], [2,1]]
+      end
+
+      it "should be able to update tail with same type" do
+        results = blockrun {[
+          space3.insert([1, [1,2,3,4], [4,3,2,1], [2,1]], return_tuple: true),
+          space3.update(1, [3, :set, [3,2,1]], return_tuple: true)
+        ]}
+        results[0].must_equal [1, [1,2,3,4], [4,3,2,1], [2,1]]
+        results[1].must_equal [1, [1,2,3,4], [4,3,2,1], [3,2,1]]
+      end
+
+      it "should be able to search by serialized value" do
+        results = blockrun {[
+          space3.insert([5, [1,2,3]]),
+          space3.insert([6, [3,2,1]]),
+          space3.first_by_key(1, [[1,2,3]]),
+          space3.first_by_key(1, [[3,2,1]]),
+        ]}
+        results[0..1].must_equal [1,1]
+        results[2].must_equal [5, [1,2,3]]
+        results[3].must_equal [6, [3,2,1]]
+      end
+    end
+  end
+end

data/test/shared_space_hash.rb

@@ -0,0 +1,239 @@
+require File.expand_path('../helper.rb', __FILE__)
+
+shared_examples_for :blocking_hash_space do
+  before { clear_db }
+
+  let(:space0) { tarantool.space_hash(0, HSPACE0[:fields], keys: HSPACE0[:keys])}
+  let(:space1) { tarantool.space_hash(1, HSPACE1[:fields], keys: HSPACE1[:keys])}
+  let(:space2) { tarantool.space_hash(2, HSPACE2[:fields], keys: HSPACE2[:keys])}
+  let(:space3) { tarantool.space_hash(3, HSPACE3[:fields], keys: HSPACE3[:keys])}
+
+  let(:vasya) { {name: 'vasya', surname: 'petrov', email: 'eb@lo.com', score: 5} }
+  let(:ilya)  { {name: 'ilya', surname: 'zimov', email: 'il@zi.bot', score: 13} }
+  let(:fedor) { {name: 'fedor', surname: 'kuklin', email: 'ku@kl.in', score: 13} }
+  let(:hozo)  { {first: 'hi zo', second: 'ho zo', third: 1} }
+  let(:pidas) { {first: 'hi zo', second: 'pidas', third: 1, _tail: [3, 5]} }
+  let(:peredoma) { {first: 'coma', second: 'peredoma', third: 2} }
+
+  it "should be selectable" do
+    results = blockrun { [
+      space0.select({name: 'vasya'}, 0, -1),
+      space0.select([{name: 'vasya'}], 0, -1),
+      space0.select([{name: 'vasya'}, {name: 'ilya'}], 0, -1),
+      space0.select([{name: 'ilya'}, {name: 'vasya'}], 0, -1),
+      space0.select([{name: 'ilya'}, {name: 'vasya'}], 0, 1),
+      space0.select([{name: 'ilya'}, {name: 'vasya'}], 1, 1),
+      space0.select({score: 13}, 0, 2),
+      space0.select({surname: 'zimov', email: 'il@zi.bot'}, 0, -1),
+    ] }
+    results[0].must_equal [vasya]
+    results[1].must_equal [vasya]
+    results[2].must_equal [vasya, ilya]
+    results[3].must_equal [ilya, vasya]
+    results[4].must_equal [ilya]
+    results[5].must_equal [vasya]
+    (results[6] - [ilya, fedor]).must_be_empty
+    ([ilya, fedor] - results[6]).must_be_empty
+    results[7].must_equal [ilya]
+  end
+  
+  it "should select tail (and have #all)" do
+    results = blockrun{ [
+      space1.all({id: 2}),
+      space2.all({third: 1})
+    ] }
+    results[0].must_equal [{id: 2, _tail: [['medium', 6], ['common', 7]]}]
+    (results[1] - [hozo, pidas]).must_be_empty
+    ([hozo, pidas] - results[1]).must_be_empty
+  end
+  
+  it "should react on #by_pk" do
+    results = blockrun{ [
+      space0.by_pk('vasya'),
+      space1.by_pk([1]),
+      space1.by_pk({id: 2}),
+      space2.by_pk(['hi zo', 'ho zo']),
+      space2.by_pk({first: 'hi zo', second: 'pidas'})
+    ] }
+    results[0].must_equal vasya
+    results[1].must_equal({id: 1, _tail: [['common', 4]]})
+    results[2].must_equal({id: 2, _tail: [['medium', 6], ['common', 7]]})
+    results[3].must_equal hozo
+    results[4].must_equal pidas
+  end
+
+  it "should react on #first" do
+    results = blockrun{ [
+      space0.first({surname: 'petrov', email: 'eb@lo.com'}),
+      space2.first({third: 1})
+    ] }
+    results[0].must_equal vasya
+    [hozo, pidas].must_include results[1]
+  end
+
+  it "should insert" do
+    petr = {name: 'petr', surname: 'kuprin', email: 'zo@na.ru', score: 1000}
+    sp1id3 = {id: 3, _tail: [['no', 8], ['more', 9], ['turtles', 10]]}
+    results = blockrun{ [
+      space0.insert(petr),
+      space0.first(score: 1000),
+      space1.insert(sp1id3, return_tuple: true)
+    ] }
+    results[0].must_equal 1
+    results[1].must_equal petr
+    results[2].must_equal sp1id3
+  end
+
+  it "should replace" do
+    huzo = {first: 'hi zo', second: 'ho zo', third: 6, _tail: [5, 4]}
+    results = blockrun{ [
+      space2.replace(huzo),
+      space2.by_pk(['hi zo', 'ho zo']),
+      space1.replace({id: 2, _tail: []}, return_tuple: true)
+    ] }
+    results[0].must_equal 1
+    results[1].must_equal huzo
+    results[2].must_equal({id: 2})
+  end
+
+  it "should update" do
+    results = blockrun{ [
+      space0.update('vasya', {score: 6}),
+      space0.by_pk('vasya'),
+      space0.update(['ilya'], {email: 'x@y.z', score: [:+, 2]}, return_tuple: true),
+      space1.update({id: 1}, {2 => 'more', 3 => 8}, return_tuple: true),
+      space1.update(2, [[2, :insert, 'high'], [2, :ins, 20]], return_tuple: true),
+      space2.update(['hi zo', 'pidas'], {_tail: [[:+, 1], [:+, -1]]}, return_tuple: true),
+    ] }
+    results[0].must_equal 1
+    results[1].must_equal vasya.merge(score: 6)
+    results[2].must_equal ilya.merge(score: 15, email: 'x@y.z')
+    results[3].must_equal({id: 1, _tail: [['common', 4], ['more', 8]]})
+    results[4].must_equal({id: 2, _tail: [['medium', 6], ['high', 20], ['common', 7]]})
+    results[5].must_equal({first: 'hi zo', second: 'pidas', third: 1, _tail: [4, 4]})
+  end
+
+  it "should delete" do
+    results = blockrun {[
+      space0.delete('vasya', return_tuple: true),
+      space0.delete(['ilya'], return_tuple: true),
+      space0.delete({name: 'fedor'}, return_tuple: true),
+      space1.delete({id: 1}),
+      space2.delete(['hi zo', 'ho zo']),
+      space2.delete({first: 'hi zo', second: 'pidas'}),
+      space2.delete(['unknown', 'man'])
+    ]}
+    results[0].must_equal vasya
+    results[1].must_equal ilya
+    results[2].must_equal fedor
+    results[3..6].must_equal [1, 1, 1, 0]
+  end
+  
+  it "should be able to call" do
+    results = blockrun {[
+      space0.call('box.select_range', [0, 2]),
+      space0.call('box.select_range', [0, 1000000, 'ilya']),
+      space0.call('func2', [1,2], types: [:int, :int], returns: [:str, :int]),
+      space0.call('func2', [1,2], types: [:int, :int], returns: {type: :str, val: :int})
+    ]} 
+    results[0].must_equal [fedor, ilya]
+    results[1].must_equal [ilya, vasya]
+    results[2].must_equal [['string', 1], ['string', 2]]
+    results[3].must_equal [{type: 'string', val: 1}, {type: 'string', val: 2}]
+  end
+
+  it "should raise error on wrong key" do
+    blockrun {
+      proc {
+        space2.insert(name: 1)
+      }.must_raise Tarantool::ArgumentError
+      proc {
+        space2.by_pk(third: 1)
+      }.must_raise Tarantool::ArgumentError
+      proc {
+        space2.first(name: 1)
+      }.must_raise Tarantool::ArgumentError
+      proc {
+        space2.all(name: 1)
+      }.must_raise Tarantool::ArgumentError
+      proc {
+        space2.select([name: 1], 0, 1)
+      }.must_raise Tarantool::ArgumentError
+      proc {
+        space2.update({third: 1}, {first: 'haha'})
+      }.must_raise Tarantool::ArgumentError
+      proc {
+        space2.update({first: 'haha'}, {first: 'haha'})
+      }.must_raise Tarantool::ArgumentError
+      proc {
+        space2.update({first: 'haha', second: 'hoho'}, {name: 'haha'})
+      }.must_raise Tarantool::ArgumentError
+    }
+  end
+
+  describe "Array Serializer" do
+    it "should be able to save" do
+      results = blockrun {[
+        space3.insert({id: 1, scores: [1,2,3,4]}, return_tuple: true),
+        space3.insert({id: 2, scores: []}, return_tuple: true),
+        space3.insert({id: 3}, return_tuple: true),
+        space3.all_by_pks([1,2,3])
+      ]}
+      results[0].must_equal({id: 1, scores: [1,2,3,4]})
+      results[1].must_equal({id: 2, scores: nil})
+      results[2].must_equal({id: 3, scores: nil})
+      results[3].sort_by{|h| h[:id]}.must_equal [
+        {id:1, scores:[1,2,3,4]},
+        {id:2, scores:nil},
+        {id:3, scores:nil}
+        ]
+    end
+    
+    it "should be able to update" do
+      results = blockrun {[
+        space3.insert({id:1, scores:[1,2,3,4]}, return_tuple: true),
+        space3.update(1, [[:scores, :set, [4,3,2,1]]], return_tuple: true)
+      ]}
+      results.must_equal [{id:1, scores:[1,2,3,4]}, {id:1, scores:[4,3,2,1]}]
+    end
+
+    it "should be able to save tail with same type" do
+      results = blockrun {[
+        space3.insert({id:1, scores:[1,2,3,4], _tail:[[4,3,2,1], [2,1]]}, return_tuple: true),
+        space3.by_pk(1)
+      ]}
+      results[0].must_equal({id:1, scores:[1,2,3,4], _tail:[[4,3,2,1], [2,1]]})
+      results[1].must_equal({id:1, scores:[1,2,3,4], _tail:[[4,3,2,1], [2,1]]})
+    end
+
+    it "should be able to update tail with same type" do
+      results = blockrun {[
+        space3.insert({id:1, scores:[1,2,3,4], _tail:[[4,3,2,1], [2,1]]}, return_tuple: true),
+        space3.update(1, {1 => [:set, [3,2,1]]}, return_tuple: true)
+      ]}
+      results[0].must_equal({id:1, scores:[1,2,3,4], _tail:[[4,3,2,1], [2,1]]})
+      results[1].must_equal({id:1, scores:[1,2,3,4], _tail:[[4,3,2,1], [3,2,1]]})
+    end
+
+    it "should be able to update tail with same type(2)" do
+      results = blockrun {[
+        space3.insert({id:1, scores:[1,2,3,4], _tail:[[4,3,2,1], [2,1]]}, return_tuple: true),
+        space3.update(1, {:_tail => [:set, [[1,2,3],[3,2,1]]]}, return_tuple: true)
+      ]}
+      results[0].must_equal({id:1, scores:[1,2,3,4], _tail:[[4,3,2,1], [2,1]]})
+      results[1].must_equal({id:1, scores:[1,2,3,4], _tail:[[1,2,3], [3,2,1]]})
+    end
+
+    it "should be able to search by serialized value" do
+      results = blockrun {[
+        space3.insert({id:5, scores:[1,2,3]}),
+        space3.insert({id:6, scores:[3,2,1]}),
+        space3.first(scores: [1,2,3]),
+        space3.first(scores: [3,2,1]),
+      ]}
+      results[0..1].must_equal [1,1]
+      results[2].must_equal({id:5, scores:[1,2,3]})
+      results[3].must_equal({id:6, scores:[3,2,1]})
+    end
+  end
+end

data/test/tarant/init.lua

@@ -0,0 +1,22 @@
+function truncate(space_no)
+    box.space[0+space_no]:truncate()
+end
+
+function func1(space_no, arg1, arg2)
+    return
+        {type(space_no), space_no},
+        {type(arg1), arg1},
+        {type(arg2), arg2}
+end
+
+function func2(space_no, arg1, arg2)
+    return
+        {type(arg1), arg1},
+        {type(arg2), arg2}
+end
+
+function func3(arg1, arg2)
+    return
+        {type(arg1), arg1},
+        {type(arg2), arg2}
+end

data/test/tarantool.cfg

@@ -0,0 +1,62 @@
+slab_alloc_arena = 0.1
+pid_file = "box.pid"
+
+logger="cat - >> tarantool.log"
+work_dir="tarant"
+
+primary_port = 33013
+secondary_port = 33014
+admin_port = 33015
+
+rows_per_wal = 50000
+
+space[0].enabled = 1
+
+space[0].index[0].type = "TREE"
+space[0].index[0].unique = 1
+space[0].index[0].key_field[0].fieldno = 0
+space[0].index[0].key_field[0].type = "STR"
+
+space[0].index[1].type = "TREE"
+space[0].index[1].unique = 0
+space[0].index[1].key_field[0].fieldno = 1
+space[0].index[1].key_field[0].type = "STR"
+space[0].index[1].key_field[1].fieldno = 2
+space[0].index[1].key_field[1].type = "STR"
+
+space[0].index[2].type = "TREE"
+space[0].index[2].unique = 0
+space[0].index[2].key_field[0].fieldno = 3
+space[0].index[2].key_field[0].type = "NUM"
+
+space[1].enabled = 1
+
+space[1].index[0].type = "HASH"
+space[1].index[0].unique = 1
+space[1].index[0].key_field[0].fieldno = 0
+space[1].index[0].key_field[0].type = "NUM"
+
+
+space[2].enabled = 1
+
+space[2].index[0].type = "TREE"
+space[2].index[0].unique = 1
+space[2].index[0].key_field[0].fieldno = 0
+space[2].index[0].key_field[0].type = "STR"
+space[2].index[0].key_field[1].fieldno = 1
+space[2].index[0].key_field[1].type = "STR"
+
+space[2].index[1].type = "TREE"
+space[2].index[1].unique = 0
+space[2].index[1].key_field[0].fieldno = 2
+space[2].index[1].key_field[0].type = "NUM"
+
+space[3].enabled = 1
+space[3].index[0].type = "HASH"
+space[3].index[0].unique = 1
+space[3].index[0].key_field[0].fieldno = 0
+space[3].index[0].key_field[0].type = "NUM"
+space[3].index[1].type = "TREE"
+space[3].index[1].unique = 0
+space[3].index[1].key_field[0].fieldno = 1
+space[3].index[1].key_field[0].type = "STR"

data/test/tarantool.log

@@ -0,0 +1,6 @@
+1341840795.677 2887 1/sched _ I> space 0 successfully configured
+1341840795.677 2887 1/sched _ I> space 1 successfully configured
+1341840795.677 2887 1/sched _ I> space 2 successfully configured
+1341840795.677 2887 1/sched _ I> recovery start
+1341840795.677 2887 1/sched _ recovery.m:274 E> can't find snapshot
+1341840795.677 2887 1/sched _ C> didn't you forget to initialize storage with --init-storage switch?

data/{spec/tarantool.cfg → test/tarantool_repl.cfg}

@@ -2,12 +2,14 @@ slab_alloc_arena = 0.1
 pid_file = "box.pid"
 
 logger="cat - >> tarantool.log"
+work_dir="tarant_repl"
 
-primary_port = 33013
-secondary_port = 33014
-admin_port = 33015
+primary_port = 34013
+secondary_port = 34014
+admin_port = 34015
+replication_source = "127.0.0.1:33012"
 
-rows_per_wal = 50
+rows_per_wal = 50000
 
 space[0].enabled = 1
 
@@ -23,6 +25,10 @@ space[0].index[1].key_field[0].type = "STR"
 space[0].index[1].key_field[1].fieldno = 2
 space[0].index[1].key_field[1].type = "STR"
 
+space[0].index[2].type = "TREE"
+space[0].index[2].unique = 0
+space[0].index[2].key_field[0].fieldno = 3
+space[0].index[2].key_field[0].type = "NUM"
 
 space[1].enabled = 1
 
@@ -44,4 +50,4 @@ space[2].index[0].key_field[1].type = "STR"
 space[2].index[1].type = "TREE"
 space[2].index[1].unique = 0
 space[2].index[1].key_field[0].fieldno = 2
-space[2].index[1].key_field[0].type = "NUM"
+space[2].index[1].key_field[0].type = "NUM"