FilesExpand file tree

 master

/

StringAggregator.java

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

141 lines (106 loc) · 3.21 KB

 master

/

StringAggregator.java

Copy path

Top

File metadata and controls

• Code
• Blame

141 lines (106 loc) · 3.21 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

package simpledb;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Set;

import simpledb.Aggregator.Op;

/**

* Knows how to compute some aggregate over a set of StringFields.

*/

public class StringAggregator implements Aggregator {

int sa_gbfield;

Type sa_gbfieldtype;

int sa_afield;

Op sa_what;

boolean no_grouping;

int count_if_not_grouping;

TupleDesc tup_desc;

HashMap<Field,Integer> gbAgg;

private static final long serialVersionUID = 1L;

/**

* Aggregate constructor

* @param gbfield the 0-based index of the group-by field in the tuple, or NO_GROUPING if there is no grouping

* @param gbfieldtype the type of the group by field (e.g., Type.INT_TYPE), or null if there is no grouping

* @param afield the 0-based index of the aggregate field in the tuple

* @param what aggregation operator to use -- only supports COUNT

* @throws IllegalArgumentException if what != COUNT

*/

public StringAggregator(int gbfield, Type gbfieldtype, int afield, Op what) {

// some code goes here

sa_gbfield = gbfield;

sa_gbfieldtype = gbfieldtype;

sa_afield = afield;

sa_what = what;

gbAgg = new HashMap<Field, Integer>();

no_grouping = (gbfieldtype == null || gbfield == NO_GROUPING);

count_if_not_grouping = 0;

tup_desc = null;

//throw IllegalArgumentException

if(what != Aggregator.Op.COUNT)

{

throw new IllegalArgumentException("what != COUNT");

}

}

/**

* Merge a new tuple into the aggregate, grouping as indicated in the constructor

* @param tup the Tuple containing an aggregate field and a group-by field

*/

public void mergeTupleIntoGroup(Tuple tup) {

// some code goes here

//save tupledescriptor for creating final table

if(tup_desc == null)

{

tup_desc = tup.getTupleDesc();

}

//not grouping - just increment count of rows

if(no_grouping)

{

count_if_not_grouping +=1;

return;

}

//grouping - add or increment Field in Hashmap

Field f = tup.getField(sa_gbfield);

if(gbAgg.containsKey(f))

{

gbAgg.put(f, gbAgg.get(f)+1);

}

else

{

gbAgg.put(f,1);

}

}

/**

* Create a DbIterator over group aggregate results.

*

* @return a DbIterator whose tuples are the pair (groupVal,

* aggregateVal) if using group, or a single (aggregateVal) if no

* grouping. The aggregateVal is determined by the type of

* aggregate specified in the constructor.

*/

public DbIterator iterator() {

//Create TupleDesc for final table

Type[] typeAr = new Type[2];

typeAr[0] = sa_gbfieldtype;

typeAr[1] = Type.INT_TYPE;

String[] fieldAr = new String[2];

fieldAr[0] = tup_desc.getFieldName(sa_gbfield);

fieldAr[1] = tup_desc.getFieldName(sa_afield);

TupleDesc table_td = new TupleDesc(typeAr, fieldAr);

//Set up container that can be iterated

ArrayList<Tuple> arr = new ArrayList<Tuple>();

Set<Field> fields = gbAgg.keySet();

for(Field field : fields)

{

int value = gbAgg.get(field);

Tuple row = new Tuple(table_td);

//first column: group by field

row.setField(0, field);

//second column: count

row.setField(1, new IntField(value));

arr.add(row);

}

//Other case: no_grouping

//Not Implemented

TupleIterator it = new TupleIterator(table_td, (Iterable<Tuple>) arr);

return it;

}

}