protected override void ProcessTuple(TexeraTuple tuple) { if (tuple.FieldList != null && tuple.FieldList[searchIndex].Contains(keyword)) { outputTuples.Enqueue(tuple); } }
protected override void ProcessTuple(TexeraTuple tuple) { string field = tuple.FieldList[joinFieldIndex]; List <string> fields = tuple.FieldList.ToList(); fields.RemoveAt(joinFieldIndex); foreach (KeyValuePair <int, Dictionary <string, List <TexeraTuple> > > entry in joinedTuples) { if (entry.Key != tuple.TableID && entry.Value.ContainsKey(field)) { foreach (TexeraTuple joinedTuple in entry.Value[field]) { outputTuples.Enqueue(new TexeraTuple(TableID, joinedTuple.FieldList.Concat(fields).ToArray())); } } } if (!joinedTuples.ContainsKey(tuple.TableID)) { Dictionary <string, List <TexeraTuple> > d = new Dictionary <string, List <TexeraTuple> >(); d.Add(field, new List <TexeraTuple> { tuple }); joinedTuples.Add(tuple.TableID, d); } else if (!joinedTuples[tuple.TableID].ContainsKey(field)) { joinedTuples[tuple.TableID].Add(field, new List <TexeraTuple> { tuple }); } else { joinedTuples[tuple.TableID][field].Add(tuple); } }
public void Accept(TexeraTuple tuple) { flag = true; var result = SentimentAnalyzer.Sentiments.Predict(tuple.FieldList[predictIndex]); resultTuple = new TexeraTuple(new string[] { tuple.FieldList[predictIndex], $"{(result.Prediction?"positive":"negative")}(Prob:{result.Probability},Score:{result.Score})" }); }
public void Accept(TexeraTuple tuple) { if (tuple.FieldList != null) { try { switch (filterType) { case FilterType.Equal: if (Parse(tuple.FieldList[filterIndex]).CompareTo(threshold) == 0) { flag = true; } break; case FilterType.Greater: if (Parse(tuple.FieldList[filterIndex]).CompareTo(threshold) > 0) { flag = true; } break; case FilterType.GreaterOrEqual: if (Parse(tuple.FieldList[filterIndex]).CompareTo(threshold) >= 0) { flag = true; } break; case FilterType.Less: if (Parse(tuple.FieldList[filterIndex]).CompareTo(threshold) < 0) { flag = true; } break; case FilterType.LessOrEqual: if (Parse(tuple.FieldList[filterIndex]).CompareTo(threshold) <= 0) { flag = true; } break; case FilterType.NotEqual: if (Parse(tuple.FieldList[filterIndex]).CompareTo(threshold) != 0) { flag = true; } break; } } catch (Exception) { } if (flag) { resultTuple = tuple; } } }
public void Accept(TexeraTuple tuple) { if (tuple.FieldList[searchIndex].Contains(keyword)) { flag = true; resultTuple = tuple; } }
public TexeraTuple Next() { var result = new TexeraTuple(currentTuple.FastConcat(currentEntry[currentIndex])); currentIndex++; if (currentIndex >= currentEntry.Count) { flag = false; } return(result); }
public void Accept(TexeraTuple tuple) { resultTuple = new TexeraTuple(new string[projectionIndexs.Count]); int i = 0; foreach (int attr in projectionIndexs) { resultTuple.FieldList[i++] = tuple.FieldList[attr]; } flag = true; }
protected override void ProcessTuple(TexeraTuple tuple) { TexeraTuple result = new TexeraTuple(tuple.TableID, new string[projectionIndexs.Count]); int i = 0; foreach (int attr in projectionIndexs) { result.FieldList[i++] = tuple.FieldList[attr]; } outputTuples.Enqueue(result); }
public void Accept(TexeraTuple tuple) { T value = Parse(tuple.FieldList[sortIndex]); int index = sortedValues.BinarySearch(value); if (index < 0) { index = ~index; } sortedTuples.Insert(index, tuple); sortedValues.Insert(index, value); }
protected override void ProcessTuple(TexeraTuple tuple) { T value = Parse(tuple.FieldList[sortIndex]); int index = sortedValues.BinarySearch(value); if (index < 0) { index = ~index; } sortedTuples.Insert(index, tuple); sortedValues.Insert(index, value); }
protected override void ProcessTuple(TexeraTuple tuple) { if (tuple.FieldList != null) { switch (type) { case FilterPredicate.FilterType.Equal: if (Parse(tuple.FieldList[filterIndex]).CompareTo(threshold) == 0) { outputTuples.Enqueue(tuple); } break; case FilterPredicate.FilterType.Greater: if (Parse(tuple.FieldList[filterIndex]).CompareTo(threshold) > 0) { outputTuples.Enqueue(tuple); } break; case FilterPredicate.FilterType.GreaterOrEqual: if (Parse(tuple.FieldList[filterIndex]).CompareTo(threshold) >= 0) { outputTuples.Enqueue(tuple); } break; case FilterPredicate.FilterType.Less: if (Parse(tuple.FieldList[filterIndex]).CompareTo(threshold) < 0) { outputTuples.Enqueue(tuple); } break; case FilterPredicate.FilterType.LessOrEqual: if (Parse(tuple.FieldList[filterIndex]).CompareTo(threshold) <= 0) { outputTuples.Enqueue(tuple); } break; case FilterPredicate.FilterType.NotEqual: if (Parse(tuple.FieldList[filterIndex]).CompareTo(threshold) != 0) { outputTuples.Enqueue(tuple); } break; } } }
public void Accept(TexeraTuple tuple) { string field = tuple.FieldList[groupByIndex]; if (counter.ContainsKey(field)) { counter[field]++; } else { counter[field] = 1; } if (aggregationFunc != AggregationType.Count) { try { double value = double.Parse(tuple.FieldList[aggregationIndex]); if (results.ContainsKey(field)) { double oldValue = results[field]; switch (aggregationFunc) { case AggregationType.Max: results[field] = Math.Max(oldValue, value); break; case AggregationType.Min: results[field] = Math.Min(oldValue, value); break; case AggregationType.Average: results[field] += value; break; case AggregationType.Sum: results[field] += value; break; } } else { results[field] = value; } } catch (Exception e) { Console.WriteLine(e); } } }
public void Accept(TexeraTuple tuple) { string field = tuple.FieldList[0]; if (aggregationFunc == AggregationType.Count) { if (counter.ContainsKey(field)) { counter[field] += int.Parse(tuple.FieldList[1]); } else { counter.Add(field, int.Parse(tuple.FieldList[1])); } } else { double value = double.Parse(tuple.FieldList[1]); if (results.ContainsKey(field)) { switch (aggregationFunc) { case AggregationType.Max: results[field] = Math.Max(results[field], value); break; case AggregationType.Min: results[field] = Math.Min(results[field], value); break; case AggregationType.Average: results[field] += value; counter[field] += int.Parse(tuple.FieldList[2]); break; case AggregationType.Sum: results[field] += value; break; } } else { results.Add(field, value); counter.Add(field, 1); } } }
protected override void ProcessTuple(TexeraTuple tuple) { try { string field = tuple.FieldList[groupByIndex]; double value = double.Parse(tuple.FieldList[aggregationIndex]); if (results.ContainsKey(field)) { counter[field]++; double oldValue = results[field]; switch (aggregationFunc) { case "max": results[field] = Math.Max(oldValue, value); break; case "min": results[field] = Math.Min(oldValue, value); break; case "avg": results[field] += value; break; case "sum": results[field] += value; break; case "count": break; } } else { results[field] = value; counter[field] = 1; } } catch (Exception e) { Console.WriteLine(e); } }
protected override void ProcessTuple(TexeraTuple tuple) { if (tableSource == -1) { tableSource = tuple.TableID; } if (tuple.TableID.Equals(tableSource)) { string source = tuple.FieldList[joinFieldIndex]; if (!hashTable.ContainsKey(source)) { hashTable[source] = new List <TexeraTuple> { tuple } } ; else { hashTable[source].Add(tuple); } } else { if (inputInfo[sourceOperator] != 0) { otherTable.Add(tuple); } else { string field = tuple.FieldList[joinFieldIndex]; List <string> fields = tuple.FieldList.ToList(); fields.RemoveAt(joinFieldIndex); foreach (TexeraTuple t in hashTable[field]) { outputTuples.Enqueue(new TexeraTuple(TableID, t.FieldList.Concat(fields).ToArray())); } } } }
private bool ReadTuple(out TexeraTuple tx) { try { ulong ByteCount; string res = reader.ReadLine(out ByteCount); start += ByteCount; if (reader.IsEOF()) { start = end + 1; tx = null; return(false); } try { tx = new TexeraTuple(tableId, res.Split(separator)); ++tuple_counter; return(true); } catch { tx = null; Console.WriteLine("Failed to parse the tuple"); return(false); } } catch (Exception ex) { Console.WriteLine("EXCEPTION in Reading Tuples from File - " + ex.ToString()); Console.WriteLine("start_offset: " + start.ToString() + " end_offset: " + end.ToString()); if (!reader.GetFile(start)) { throw new Exception("Reading Tuple: Cannot Get File"); } tx = null; return(false); } }
public void Accept(TexeraTuple tuple) { string field = tuple.FieldList[joinFieldIndex]; List <string> fields = tuple.FieldList.ToList(); if (joinedTuples.ContainsKey(field)) { foreach (TexeraTuple joinedTuple in joinedTuples[field]) { output.Enqueue(new TexeraTuple(joinedTuple.FieldList.Concat(fields).ToArray())); } } if (!toInsert.ContainsKey(field)) { toInsert.Add(field, new List <TexeraTuple> { tuple }); } else { toInsert[field].Add(tuple); } }
public void Accept(TexeraTuple tuple) { if (isCurrentInnerTable) { string source = tuple.FieldList[innerTableIndex]; if (!hashTable.ContainsKey(source)) { hashTable[source] = new List <string[]> { tuple.FieldList.RemoveAt(innerTableIndex) } } ; else { hashTable[source].Add(tuple.FieldList.RemoveAt(innerTableIndex)); } } else { if (!isInnerTableFinished) { otherTable.Add(tuple); } else { string field = tuple.FieldList[outerTableIndex]; if (hashTable.ContainsKey(field)) { flag = true; currentIndex = 0; currentEntry = hashTable[field]; currentTuple = tuple.FieldList; } } } }
protected override void ProcessTuple(TexeraTuple tuple) { //Console.WriteLine(++counter+" tuple processed"); foreach (KeyValuePair <int, List <TexeraTuple> > entry in CrossRippleJoinedTuples) { if (entry.Key != tuple.TableID) { foreach (TexeraTuple t in entry.Value) { outputTuples.Enqueue(new TexeraTuple(TableID, tuple.FieldList.Concat(t.FieldList).ToArray())); } } } if (CrossRippleJoinedTuples.ContainsKey(tuple.TableID)) { CrossRippleJoinedTuples[tuple.TableID].Add(tuple); } else { CrossRippleJoinedTuples.Add(tuple.TableID, new List <TexeraTuple> { tuple }); } }
public abstract void Accept(TexeraTuple tuple);
public void Accept(TexeraTuple tuple) { sws[NonNegativeModular(hashFunc(tuple), numBuckets)].WriteLine(String.Join("|", tuple.FieldList)); }
public void Accept(TexeraTuple tuple) { sws.WriteLine(String.Join("|", tuple.FieldList)); }
protected virtual void ProcessTuple(TexeraTuple tuple) { }
protected override void ProcessTuple(TexeraTuple tuple) { count++; }
protected override void ProcessTuple(TexeraTuple tuple) { count += int.Parse(tuple.FieldList[0]); }
public void Accept(TexeraTuple tuple) { count += int.Parse(tuple.FieldList[0]); }
public void Accept(TexeraTuple tuple) { count++; receivedCounter++; }
public override void Accept(TexeraTuple tuple) { this.current++; }