/// <exception cref="System.IO.IOException"/> public SequenceFileAsTextRecordReader(Configuration conf, FileSplit split) { sequenceFileRecordReader = new SequenceFileRecordReader <WritableComparable, Writable >(conf, split); innerKey = sequenceFileRecordReader.CreateKey(); innerValue = sequenceFileRecordReader.CreateValue(); }
/// <exception cref="System.Exception"/> public virtual int TestFormat(Configuration conf, int tupleSize, bool firstTuple, bool secondTuple, TestJoinProperties.TestType ttype) { Job job = Job.GetInstance(conf); CompositeInputFormat format = new CompositeInputFormat(); int count = 0; foreach (InputSplit split in (IList <InputSplit>)format.GetSplits(job)) { TaskAttemptContext context = MapReduceTestUtil.CreateDummyMapTaskAttemptContext(conf ); RecordReader reader = format.CreateRecordReader(split, context); MapContext mcontext = new MapContextImpl(conf, context.GetTaskAttemptID(), reader , null, null, MapReduceTestUtil.CreateDummyReporter(), split); reader.Initialize(split, mcontext); WritableComparable key = null; Writable value = null; while (reader.NextKeyValue()) { key = (WritableComparable)reader.GetCurrentKey(); value = (Writable)reader.GetCurrentValue(); ValidateKeyValue(key, value, tupleSize, firstTuple, secondTuple, ttype); count++; } } return(count); }
// Mapper that sleeps for a long time. // Used for running a job that will be killed /// <exception cref="System.IO.IOException"/> protected override void Map <_T0>(WritableComparable <_T0> key, Writable value, Mapper.Context context) { try { Sharpen.Thread.Sleep(1000000); } catch (Exception) { } }
/// <summary> /// Break the prefix string into moves (a sequence of integer row ids that /// will be selected for each column in order). /// </summary> /// <remarks> /// Break the prefix string into moves (a sequence of integer row ids that /// will be selected for each column in order). Find all solutions with /// that prefix. /// </remarks> /// <exception cref="System.IO.IOException"/> protected override void Map <_T0>(WritableComparable <_T0> key, Text value, Mapper.Context context) { prefixString = value; StringTokenizer itr = new StringTokenizer(prefixString.ToString(), ","); int[] prefix = new int[depth]; int idx = 0; while (itr.HasMoreTokens()) { string num = itr.NextToken(); prefix[idx++] = System.Convert.ToInt32(num); } pent.Solve(prefix); }
public virtual void TestSortedMapWritable() { Text[] keys = new Text[] { new Text("key1"), new Text("key2"), new Text("key3") }; BytesWritable[] values = new BytesWritable[] { new BytesWritable(Runtime.GetBytesForString ("value1")), new BytesWritable(Runtime.GetBytesForString("value2")), new BytesWritable(Runtime.GetBytesForString("value3")) }; SortedMapWritable inMap = new SortedMapWritable(); for (int i = 0; i < keys.Length; i++) { inMap[keys[i]] = values[i]; } Assert.Equal(0, inMap.FirstKey().CompareTo(keys[0])); Assert.Equal(0, inMap.LastKey().CompareTo(keys[2])); SortedMapWritable outMap = new SortedMapWritable(inMap); Assert.Equal(inMap.Count, outMap.Count); foreach (KeyValuePair <WritableComparable, Writable> e in inMap) { Assert.True(outMap.Contains(e.Key)); Assert.Equal(0, ((WritableComparable)outMap[e.Key]).CompareTo( e.Value)); } // Now for something a little harder... Text[] maps = new Text[] { new Text("map1"), new Text("map2") }; SortedMapWritable mapOfMaps = new SortedMapWritable(); mapOfMaps[maps[0]] = inMap; mapOfMaps[maps[1]] = outMap; SortedMapWritable copyOfMapOfMaps = new SortedMapWritable(mapOfMaps); for (int i_1 = 0; i_1 < maps.Length; i_1++) { Assert.True(copyOfMapOfMaps.Contains(maps[i_1])); SortedMapWritable a = (SortedMapWritable)mapOfMaps[maps[i_1]]; SortedMapWritable b = (SortedMapWritable)copyOfMapOfMaps[maps[i_1]]; Assert.Equal(a.Count, b.Count); foreach (Writable key in a.Keys) { Assert.True(b.Contains(key)); // This will work because we know what we put into each set WritableComparable aValue = (WritableComparable)a[key]; WritableComparable bValue = (WritableComparable)b[key]; Assert.Equal(0, aValue.CompareTo(bValue)); } } }
/// <exception cref="System.IO.IOException"/> public virtual void Reduce(WritableComparable key, IEnumerator values, OutputCollector output, Reporter reporter) { if (first) { first = false; MapOutputFile mapOutputFile = new MROutputFiles(); mapOutputFile.SetConf(conf); Path input = mapOutputFile.GetInputFile(0); FileSystem fs = FileSystem.Get(conf); NUnit.Framework.Assert.IsTrue("reduce input exists " + input, fs.Exists(input)); SequenceFile.Reader rdr = new SequenceFile.Reader(fs, input, conf); NUnit.Framework.Assert.AreEqual("is reduce input compressed " + input, compressInput , rdr.IsCompressed()); rdr.Close(); } }
public override int Compare(WritableComparable v1, WritableComparable v2) { int val1 = ((IntWritable)(v1)).Get() / 100; int val2 = ((IntWritable)(v2)).Get() / 100; if (val1 < val2) { return(1); } else { if (val1 > val2) { return(-1); } else { return(0); } } }
/// <exception cref="System.IO.IOException"/> private void ValidateKeyValue <_T0>(WritableComparable <_T0> k, Writable v, int tupleSize , bool firstTuple, bool secondTuple, TestJoinProperties.TestType ttype) { System.Console.Out.WriteLine("out k:" + k + " v:" + v); if (ttype.Equals(TestJoinProperties.TestType.OuterAssociativity)) { ValidateOuterKeyValue((IntWritable)k, (TupleWritable)v, tupleSize, firstTuple, secondTuple ); } else { if (ttype.Equals(TestJoinProperties.TestType.InnerAssociativity)) { ValidateInnerKeyValue((IntWritable)k, (TupleWritable)v, tupleSize, firstTuple, secondTuple ); } } if (ttype.Equals(TestJoinProperties.TestType.InnerIdentity)) { ValidateKeyValue_INNER_IDENTITY((IntWritable)k, (IntWritable)v); } }
/// <exception cref="System.IO.IOException"/> /// <exception cref="System.Exception"/> protected override void Map <_T0>(WritableComparable <_T0> key, Text val, Mapper.Context context) { context.Write(new IntWritable(System.Convert.ToInt32(val.ToString().Trim())), new IntWritable(1)); }
/// <summary>Read the next key in a set into <code>key</code>.</summary> /// <remarks> /// Read the next key in a set into <code>key</code>. Returns /// true if such a key exists and false when at the end of the set. /// </remarks> /// <exception cref="System.IO.IOException"/> public virtual bool Next(WritableComparable key) { return(Next(key, NullWritable.Get())); }
// javadoc inherited /// <exception cref="System.IO.IOException"/> public override bool Seek(WritableComparable key) { return(base.Seek(key)); }
// no public ctor /// <summary>Append a key to a set.</summary> /// <remarks> /// Append a key to a set. The key must be strictly greater than the /// previous key added to the set. /// </remarks> /// <exception cref="System.IO.IOException"/> public virtual void Append(WritableComparable key) { Append(key, NullWritable.Get()); }
public override int Compare(WritableComparable a, WritableComparable b) { TestComparators.MyWritable aa = (TestComparators.MyWritable)a; TestComparators.MyWritable bb = (TestComparators.MyWritable)b; return(aa.j - bb.j); }
public override int Compare(WritableComparable v1, WritableComparable v2) { return(-base.Compare(v1, v2)); }
/// <exception cref="System.IO.IOException"/> public virtual void MapItem(WritableComparable key, Writable value) { WritableUtils.WriteVInt(stream, BinaryProtocol.MessageType.MapItem.code); WriteObject(key); WriteObject(value); }
/// <exception cref="System.IO.IOException"/> public virtual void ReduceKey(WritableComparable key) { WritableUtils.WriteVInt(stream, BinaryProtocol.MessageType.ReduceKey.code); WriteObject(key); }
// Mapper that fails /// <exception cref="System.IO.IOException"/> protected override void Map <_T0>(WritableComparable <_T0> key, Writable value, Mapper.Context context) { throw new RuntimeException("failing map"); }
/// <exception cref="System.IO.IOException"/> public override void Write <_T0>(WritableComparable <_T0> key, Writable value) { @out.Append(key, value); }