public VTuple(Datum [] datum) { this(datum.length); put(datum); }
@Override public void put(int fieldId, Datum value) { super.put(fieldId, value); updateHashCode(); }
@Override public void put(Datum [] values) { super.put(values); updateHashCode(); }
@Override public void put(int fieldId, Tuple tuple) { super.put(fieldId, tuple); updateHashCode(); }
@Override public void put(int fieldId, Datum value) { super.put(fieldId, value); updateHashCode(); }
@Override public void put(Datum [] values) { super.put(values); updateHashCode(); }
@Override public void put(int fieldId, Tuple tuple) { this.put(fieldId, tuple.asDatum(fieldId)); }
@Override public void insertTuple(int fieldId, Tuple tuple) { this.put(fieldId, tuple.asDatum(fieldId)); }
public void analyzeField(int idx, Tuple tuple) { if (columnStatsEnabled[idx]) { if (tuple.isBlankOrNull(idx)) { numNulls[idx]++; return; } Datum datum = tuple.asDatum(idx); if (!maxValues.contains(idx) || maxValues.get(idx).compareTo(datum) < 0) { maxValues.put(idx, datum); } if (!minValues.contains(idx) || minValues.get(idx).compareTo(datum) > 0) { minValues.put(idx, datum); } } }
public void analyzeField(int idx, Tuple tuple) { if (columnStatsEnabled[idx]) { if (tuple.isBlankOrNull(idx)) { numNulls[idx]++; return; } Datum datum = tuple.asDatum(idx); if (!maxValues.contains(idx) || maxValues.get(idx).compareTo(datum) < 0) { maxValues.put(idx, datum); } if (!minValues.contains(idx) || minValues.get(idx).compareTo(datum) > 0) { minValues.put(idx, datum); } } }
@Test public void testClone() throws CloneNotSupportedException { VTuple t1 = new VTuple(5); t1.put(0, DatumFactory.createInt4(1)); t1.put(1, DatumFactory.createInt4(2)); t1.put(3, DatumFactory.createInt4(2)); t1.put(4, DatumFactory.createText("str")); VTuple t2 = t1.clone(); assertNotSame(t1, t2); assertEquals(t1, t2); assertSame(t1.get(4), t2.get(4)); t1.clear(); assertFalse(t1.equals(t2)); } }
@Test public void testPartitionForOnePartNumWithOneOfTheValueNull() { Schema schema = SchemaBuilder.builder() .add("l_returnflag", Type.TEXT) .add("l_linestatus", Type.TEXT) .build(); SortSpec [] sortSpecs = PlannerUtil.schemaToSortSpecs(schema); VTuple s = new VTuple(2); s.put(0, DatumFactory.createNullDatum()); s.put(1, DatumFactory.createText("F")); VTuple e = new VTuple(2); e.put(0, DatumFactory.createText("R")); e.put(1, DatumFactory.createNullDatum()); TupleRange expected = new TupleRange(sortSpecs, s, e); RangePartitionAlgorithm partitioner = new UniformRangePartition(expected, sortSpecs, true); TupleRange [] ranges = partitioner.partition(1); assertEquals(expected, ranges[0]); }
@Test public void testPartitionForOnePartNum() { Schema schema = SchemaBuilder.builder() .add("l_returnflag", Type.TEXT) .add("l_linestatus", Type.TEXT) .build(); SortSpec [] sortSpecs = PlannerUtil.schemaToSortSpecs(schema); VTuple s = new VTuple(2); s.put(0, DatumFactory.createText("A")); s.put(1, DatumFactory.createText("F")); VTuple e = new VTuple(2); e.put(0, DatumFactory.createText("R")); e.put(1, DatumFactory.createText("O")); TupleRange expected = new TupleRange(sortSpecs, s, e); RangePartitionAlgorithm partitioner = new UniformRangePartition(expected, sortSpecs, true); TupleRange [] ranges = partitioner.partition(1); assertEquals(expected, ranges[0]); }
@Test public void testPartitionForOnePartNumWithBothValueNull() { Schema schema = SchemaBuilder.builder() .add("l_returnflag", Type.TEXT) .add("l_linestatus", Type.TEXT) .build(); SortSpec [] sortSpecs = PlannerUtil.schemaToSortSpecs(schema); VTuple s = new VTuple(2); s.put(0, DatumFactory.createNullDatum()); s.put(1, DatumFactory.createNullDatum()); VTuple e = new VTuple(2); e.put(0, DatumFactory.createNullDatum()); e.put(1, DatumFactory.createNullDatum()); TupleRange expected = new TupleRange(sortSpecs, s, e); RangePartitionAlgorithm partitioner = new UniformRangePartition(expected, sortSpecs, true); TupleRange [] ranges = partitioner.partition(1); assertEquals(expected, ranges[0]); }
@Test public void testPut() { VTuple t1 = new VTuple(260); t1.put(0, DatumFactory.createText("str")); t1.put(1, DatumFactory.createInt4(2)); t1.put(257, DatumFactory.createFloat4(0.76f)); assertTrue(t1.contains(0)); assertTrue(t1.contains(1)); assertEquals(t1.getText(0),"str"); assertEquals(t1.get(1).asInt4(),2); assertTrue(t1.get(257).asFloat4() == 0.76f); }
@Test public void testContain() { VTuple t1 = new VTuple(260); t1.put(0, DatumFactory.createInt4(1)); t1.put(1, DatumFactory.createInt4(1)); t1.put(27, DatumFactory.createInt4(1)); t1.put(96, DatumFactory.createInt4(1)); t1.put(257, DatumFactory.createInt4(1)); assertTrue(t1.contains(0)); assertTrue(t1.contains(1)); assertFalse(t1.contains(2)); assertFalse(t1.contains(3)); assertFalse(t1.contains(4)); assertTrue(t1.contains(27)); assertFalse(t1.contains(28)); assertFalse(t1.contains(95)); assertTrue(t1.contains(96)); assertFalse(t1.contains(97)); assertTrue(t1.contains(257)); }
@Test public void testIncrementOfUnicode() { Schema schema = SchemaBuilder.builder() .add("col1", Type.TEXT) .build(); SortSpec [] sortSpecs = PlannerUtil.schemaToSortSpecs(schema); VTuple s = new VTuple(1); s.put(0, DatumFactory.createText("가가가")); VTuple e = new VTuple(1); e.put(0, DatumFactory.createText("하하하")); TupleRange expected = new TupleRange(sortSpecs, s, e); UniformRangePartition partitioner = new UniformRangePartition(expected, sortSpecs); BaseTupleComparator comp = new BaseTupleComparator(schema, sortSpecs); Tuple tuple = s; Tuple prevTuple = null; for (int i = 0; i < 100; i++) { tuple = partitioner.increment(tuple, BigInteger.valueOf(30000), 0); if (prevTuple != null) { assertTrue("prev=" + prevTuple + ", current=" + tuple, comp.compare(prevTuple, tuple) < 0); } prevTuple = tuple; } }
@Test public void testPartitionForUnicodeDiffLenBeginTextAsc() { Schema schema = SchemaBuilder.builder().add("col1", Type.TEXT).build(); SortSpec [] sortSpecs = PlannerUtil.schemaToSortSpecs(schema); VTuple s = new VTuple(1); VTuple e = new VTuple(1); s.put(0, DatumFactory.createText("가")); e.put(0, DatumFactory.createText("하하하")); TupleRange expected = new TupleRange(sortSpecs, s, e); UniformRangePartition partitioner = new UniformRangePartition(expected, sortSpecs); int partNum = 64; TupleRange [] ranges = partitioner.partition(partNum); TupleRange prev = null; for (TupleRange r : ranges) { if (prev != null) { assertTrue(prev.compareTo(r) < 0); } prev = r; } assertEquals(partNum, ranges.length); assertTrue(ranges[0].getStart().equals(s)); assertTrue(ranges[partNum - 1].getEnd().equals(e)); }
@Test public void testPartitionForUnicodeTextDesc() { Schema schema = SchemaBuilder.builder().add("col1", Type.TEXT).build(); SortSpec [] sortSpecs = PlannerUtil.schemaToSortSpecs(schema); sortSpecs[0].setDescOrder(); VTuple s = new VTuple(1); VTuple e = new VTuple(1); s.put(0, DatumFactory.createText("하하하")); e.put(0, DatumFactory.createText("가가가")); TupleRange expected = new TupleRange(sortSpecs, s, e); UniformRangePartition partitioner = new UniformRangePartition(expected, sortSpecs); int partNum = 64; TupleRange [] ranges = partitioner.partition(partNum); TupleRange prev = null; for (TupleRange r : ranges) { if (prev != null) { assertTrue(prev.compareTo(r) < 0); } prev = r; } assertEquals(partNum, ranges.length); assertTrue(ranges[0].getStart().equals(s)); assertTrue(ranges[partNum - 1].getEnd().equals(e)); }
@Test public void testTupleEval() throws CloneNotSupportedException { ConstEval e1 = new ConstEval(DatumFactory.createInt4(1)); assertCloneEqual(e1); FieldEval e2 = new FieldEval("table1.score", CatalogUtil.newSimpleDataType(INT4)); // it indicates assertCloneEqual(e2); Schema schema1 = SchemaBuilder.builder() .add("table1.id", INT4) .add("table1.score", INT4) .build(); BinaryEval expr = new BinaryEval(EvalType.PLUS, e1, e2); expr.bind(null, schema1); assertCloneEqual(expr); VTuple tuple = new VTuple(2); tuple.put(0, DatumFactory.createInt4(1)); // put 0th field tuple.put(1, DatumFactory.createInt4(99)); // put 1th field // the result of evaluation must be 100. assertEquals(expr.eval(tuple).asInt4(), 100); }