Skip to content

Commit ad105d8

Browse files
author
Angus Davis
committed
Merge pull request #28 from carterpage/delete-tests
2 parents ad11ecd + e67c611 commit ad105d8

File tree

1 file changed

+303
-28
lines changed

1 file changed

+303
-28
lines changed

‎src/test/java/com/google/cloud/anviltop/hbase/TestDelete.java‎

Lines changed: 303 additions & 28 deletions
Original file line numberDiff line numberDiff line change
@@ -13,42 +13,317 @@
1313
*/
1414
package com.google.cloud.anviltop.hbase;
1515

16+
import org.apache.hadoop.hbase.Cell;
17+
import org.apache.hadoop.hbase.CellUtil;
1618
import org.apache.hadoop.hbase.client.Delete;
1719
import org.apache.hadoop.hbase.client.Get;
1820
import org.apache.hadoop.hbase.client.HTableInterface;
1921
import org.apache.hadoop.hbase.client.Put;
22+
import org.apache.hadoop.hbase.client.Result;
2023
import org.junit.Assert;
2124
import org.junit.Test;
2225

2326
import java.io.IOException;
27+
import java.util.List;
2428

2529
public class TestDelete extends AbstractTest {
26-
/**
27-
* Requirement 4.1 - Delete all data for a given rowkey.
28-
*/
29-
@Test
30-
public void testDeleteRow() throws IOException {
31-
// Initialize data
32-
HTableInterface table = connection.getTable(TABLE_NAME);
33-
byte[] rowKey = dataHelper.randomData("testrow-");
34-
byte[] qual = dataHelper.randomData("qual-");
35-
byte[] value = dataHelper.randomData("value-");
36-
37-
// Insert empty values. Null and byte[0] are interchangeable for puts (but not gets).
38-
Put put = new Put(rowKey);
39-
put.add(COLUMN_FAMILY, qual, 1L, value);
40-
put.add(COLUMN_FAMILY, qual, 2L, value);
41-
table.put(put);
42-
43-
// Check values
44-
Get get = new Get(rowKey);
45-
Assert.assertTrue(table.exists(get));
46-
47-
// Delete row
48-
Delete delete = new Delete(rowKey);
49-
table.delete(delete);
50-
Assert.assertFalse(table.exists(get));
51-
52-
table.close();
53-
}
30+
/**
31+
* Requirement 4.1 - Delete all data for a given rowkey.
32+
*/
33+
@Test
34+
public void testDeleteRow() throws IOException {
35+
// Initialize data
36+
HTableInterface table = connection.getTable(TABLE_NAME);
37+
byte[] rowKey = dataHelper.randomData("testrow-");
38+
byte[] qual1 = dataHelper.randomData("qual-");
39+
byte[] qual2 = dataHelper.randomData("qual-");
40+
byte[] value = dataHelper.randomData("value-");
41+
42+
Put put = new Put(rowKey);
43+
put.add(COLUMN_FAMILY, qual1, 1L, value);
44+
put.add(COLUMN_FAMILY, qual1, 2L, value);
45+
put.add(COLUMN_FAMILY, qual2, 1L, value);
46+
table.put(put);
47+
48+
// Check values
49+
Get get = new Get(rowKey);
50+
Assert.assertTrue(table.exists(get));
51+
52+
// Delete row
53+
Delete delete = new Delete(rowKey);
54+
table.delete(delete);
55+
Assert.assertFalse("Entire row should be deleted.", table.exists(get));
56+
57+
table.close();
58+
}
59+
60+
/**
61+
* Requirement 4.2 - Delete the latest version of a specific column (family:qualifier)
62+
*/
63+
@Test
64+
public void testDeleteLatestColumnVersion() throws IOException {
65+
// Initialize data
66+
HTableInterface table = connection.getTable(TABLE_NAME);
67+
byte[] rowKey = dataHelper.randomData("testrow-");
68+
byte[] qual = dataHelper.randomData("qual-");
69+
byte[] value = dataHelper.randomData("value-");
70+
Put put = new Put(rowKey);
71+
put.add(COLUMN_FAMILY, qual, 1L, value);
72+
put.add(COLUMN_FAMILY, qual, 2L, value);
73+
table.put(put);
74+
75+
// Check values
76+
Get get = new Get(rowKey);
77+
get.setMaxVersions(5);
78+
Result result = table.get(get);
79+
Assert.assertEquals(2, result.size());
80+
81+
// Delete latest column version
82+
Delete delete = new Delete(rowKey);
83+
delete.deleteColumn(COLUMN_FAMILY, qual);
84+
table.delete(delete);
85+
86+
// Confirm results.
87+
result = table.get(get);
88+
Assert.assertEquals(1, result.size());
89+
Assert.assertEquals("Version 2 should be deleted, but not version 1.",
90+
1L, result.getColumnLatestCell(COLUMN_FAMILY, qual).getTimestamp());
91+
92+
table.close();
93+
}
94+
95+
/**
96+
* Requirement 4.3 - Delete a specific version of a specific column (family:qualifer + ts)
97+
*/
98+
@Test
99+
public void testDeleteSpecificColumnVersion() throws IOException {
100+
// Initialize data
101+
HTableInterface table = connection.getTable(TABLE_NAME);
102+
byte[] rowKey = dataHelper.randomData("testrow-");
103+
byte[] qual = dataHelper.randomData("qual-");
104+
byte[] value = dataHelper.randomData("value-");
105+
Put put = new Put(rowKey);
106+
put.add(COLUMN_FAMILY, qual, 1L, value);
107+
put.add(COLUMN_FAMILY, qual, 2L, value);
108+
put.add(COLUMN_FAMILY, qual, 3L, value);
109+
table.put(put);
110+
111+
// Check values
112+
Get get = new Get(rowKey);
113+
get.setMaxVersions(5);
114+
Result result = table.get(get);
115+
Assert.assertEquals(3, result.size());
116+
117+
// Delete latest column version
118+
Delete delete = new Delete(rowKey);
119+
delete.deleteColumn(COLUMN_FAMILY, qual, 2L);
120+
table.delete(delete);
121+
122+
// Confirm results
123+
result = table.get(get);
124+
Assert.assertEquals("Only one version should be deleted", 2, result.size());
125+
List<Cell> cells = result.getColumnCells(COLUMN_FAMILY, qual);
126+
Assert.assertEquals("Version 3 should be the latest version", 3L, cells.get(0).getTimestamp());
127+
Assert.assertEquals("Version 1 should be the oldest version", 1L, cells.get(1).getTimestamp());
128+
129+
table.close();
130+
}
131+
132+
/**
133+
* Requirement 4.4 - Delete all versions of a specific column
134+
*/
135+
@Test
136+
public void testDeleteAllColumnVersions() throws IOException {
137+
// Initialize data
138+
HTableInterface table = connection.getTable(TABLE_NAME);
139+
byte[] rowKey = dataHelper.randomData("testrow-");
140+
byte[] qual1 = dataHelper.randomData("qual-");
141+
byte[] qual2 = dataHelper.randomData("qual-");
142+
byte[] value = dataHelper.randomData("value-");
143+
144+
Put put = new Put(rowKey);
145+
put.add(COLUMN_FAMILY, qual1, 1L, value);
146+
put.add(COLUMN_FAMILY, qual1, 2L, value);
147+
put.add(COLUMN_FAMILY, qual2, 1L, value);
148+
table.put(put);
149+
150+
// Check values
151+
Get get = new Get(rowKey);
152+
get.setMaxVersions(5);
153+
Result result = table.get(get);
154+
Assert.assertEquals(3, result.size());
155+
156+
// Delete row
157+
Delete delete = new Delete(rowKey);
158+
delete.deleteColumns(COLUMN_FAMILY, qual1);
159+
table.delete(delete);
160+
161+
// Check results
162+
result = table.get(get);
163+
Assert.assertEquals("Qual1 values should have been deleted", 1, result.size());
164+
Assert.assertTrue("Qual2 should be intact", result.containsColumn(COLUMN_FAMILY, qual2));
165+
Assert.assertArrayEquals("Qual2 value should match", qual2,
166+
CellUtil.cloneQualifier(result.getColumnLatestCell(COLUMN_FAMILY, qual2)));
167+
168+
table.close();
169+
}
170+
171+
/**
172+
* Requirement 4.5 - Delete all versions of a specific column less than or equal to a given timestamp.
173+
*/
174+
@Test
175+
public void testDeleteOlderColumnVersions() throws IOException {
176+
// Initialize data
177+
HTableInterface table = connection.getTable(TABLE_NAME);
178+
byte[] rowKey = dataHelper.randomData("testrow-");
179+
byte[] qual = dataHelper.randomData("qual-");
180+
byte[] value = dataHelper.randomData("value-");
181+
Put put = new Put(rowKey);
182+
put.add(COLUMN_FAMILY, qual, 1L, value);
183+
put.add(COLUMN_FAMILY, qual, 2L, value);
184+
put.add(COLUMN_FAMILY, qual, 3L, value);
185+
table.put(put);
186+
187+
// Check values
188+
Get get = new Get(rowKey);
189+
get.setMaxVersions(5);
190+
Result result = table.get(get);
191+
Assert.assertEquals(3, result.size());
192+
193+
// Delete latest column version
194+
Delete delete = new Delete(rowKey);
195+
delete.deleteColumns(COLUMN_FAMILY, qual, 2L);
196+
table.delete(delete);
197+
198+
// Confirm results
199+
result = table.get(get);
200+
Assert.assertEquals("Only one version should remain", 1, result.size());
201+
Assert.assertEquals("Version 3 should be the only version", 3L,
202+
result.getColumnLatestCell(COLUMN_FAMILY, qual).getTimestamp());
203+
204+
table.close();
205+
}
206+
207+
/**
208+
* Requirement 4.6 - Delete all versions of all columns of a particular family.
209+
*/
210+
@Test
211+
public void testDeleteFamily() throws IOException {
212+
// Initialize data
213+
HTableInterface table = connection.getTable(TABLE_NAME);
214+
byte[] rowKey = dataHelper.randomData("testrow-");
215+
byte[] qual1 = dataHelper.randomData("qual-");
216+
byte[] qual2 = dataHelper.randomData("qual-");
217+
byte[] value = dataHelper.randomData("value-");
218+
219+
Put put = new Put(rowKey);
220+
put.add(COLUMN_FAMILY, qual1, 1L, value);
221+
put.add(COLUMN_FAMILY, qual1, 2L, value);
222+
put.add(COLUMN_FAMILY, qual2, 1L, value);
223+
table.put(put);
224+
225+
// Check values
226+
Get get = new Get(rowKey);
227+
get.setMaxVersions(5);
228+
Result result = table.get(get);
229+
Assert.assertEquals(3, result.size());
230+
231+
// Delete row
232+
Delete delete = new Delete(rowKey);
233+
delete.deleteFamily(COLUMN_FAMILY);
234+
table.delete(delete);
235+
236+
// Check results
237+
Assert.assertFalse("All of the family should be deleted", table.exists(get));
238+
239+
table.close();
240+
}
241+
242+
/**
243+
* Requirement 4.7 - Delete all columns of a particular family less than or equal to a timestamp.
244+
*/
245+
@Test
246+
public void testDeleteOlderFamilyColumns() throws IOException {
247+
// Initialize data
248+
HTableInterface table = connection.getTable(TABLE_NAME);
249+
byte[] rowKey = dataHelper.randomData("testrow-");
250+
byte[] qual1 = dataHelper.randomData("qual-");
251+
byte[] qual2 = dataHelper.randomData("qual-");
252+
byte[] value = dataHelper.randomData("value-");
253+
254+
Put put = new Put(rowKey);
255+
put.add(COLUMN_FAMILY, qual1, 1L, value);
256+
put.add(COLUMN_FAMILY, qual1, 2L, value);
257+
put.add(COLUMN_FAMILY, qual1, 3L, value);
258+
put.add(COLUMN_FAMILY, qual2, 1L, value);
259+
put.add(COLUMN_FAMILY, qual2, 2L, value);
260+
table.put(put);
261+
262+
// Check values
263+
Get get = new Get(rowKey);
264+
get.setMaxVersions(5);
265+
Result result = table.get(get);
266+
Assert.assertEquals(5, result.size());
267+
268+
// Delete row
269+
Delete delete = new Delete(rowKey);
270+
delete.deleteFamily(COLUMN_FAMILY, 2L);
271+
table.delete(delete);
272+
273+
// Confirm results
274+
result = table.get(get);
275+
Assert.assertEquals("Only one version of qual1 should remain", 1, result.size());
276+
Assert.assertTrue("Qual1 should be the remaining cell", result.containsColumn(COLUMN_FAMILY, qual1));
277+
Assert.assertEquals("Version 3 should be the only version", 3L,
278+
result.getColumnLatestCell(COLUMN_FAMILY, qual1).getTimestamp());
279+
280+
table.close();
281+
}
282+
283+
/**
284+
* Requirement 4.8 - Delete all columns of a family with a specific ts.
285+
*/
286+
@Test
287+
public void testDeleteFamilyWithSpecificTimestamp() throws IOException {
288+
// Initialize data
289+
HTableInterface table = connection.getTable(TABLE_NAME);
290+
byte[] rowKey = dataHelper.randomData("testrow-");
291+
byte[] qual1 = dataHelper.randomData("qual-");
292+
byte[] qual2 = dataHelper.randomData("qual-");
293+
byte[] value = dataHelper.randomData("value-");
294+
295+
Put put = new Put(rowKey);
296+
put.add(COLUMN_FAMILY, qual1, 1L, value);
297+
put.add(COLUMN_FAMILY, qual1, 2L, value);
298+
put.add(COLUMN_FAMILY, qual1, 3L, value);
299+
put.add(COLUMN_FAMILY, qual2, 1L, value);
300+
put.add(COLUMN_FAMILY, qual2, 2L, value);
301+
table.put(put);
302+
303+
// Check values
304+
Get get = new Get(rowKey);
305+
get.setMaxVersions(5);
306+
Result result = table.get(get);
307+
Assert.assertEquals(5, result.size());
308+
309+
// Delete row
310+
Delete delete = new Delete(rowKey);
311+
delete.deleteFamilyVersion(COLUMN_FAMILY, 2L);
312+
table.delete(delete);
313+
314+
// Confirm results
315+
result = table.get(get);
316+
Assert.assertEquals("Three versions should remain", 3, result.size());
317+
Assert.assertTrue("Qual1 should have cells", result.containsColumn(COLUMN_FAMILY, qual1));
318+
Assert.assertTrue("Qual2 should have a cell", result.containsColumn(COLUMN_FAMILY, qual2));
319+
List<Cell> cells1 = result.getColumnCells(COLUMN_FAMILY, qual1);
320+
Assert.assertEquals("Qual1 should have 2 cells", 2, cells1.size());
321+
Assert.assertEquals("Version 3 should be the latest version", 3L, cells1.get(0).getTimestamp());
322+
Assert.assertEquals("Version 1 should be the oldest version", 1L, cells1.get(1).getTimestamp());
323+
List<Cell> cells2 = result.getColumnCells(COLUMN_FAMILY, qual2);
324+
Assert.assertEquals("Qual2 should have 1 cell", 1, cells2.size());
325+
Assert.assertEquals("Version 1 should be the latest version", 1L, cells2.get(0).getTimestamp());
326+
327+
table.close();
328+
}
54329
}

0 commit comments

Comments
 (0)