/** Unit test for TupleDesc.combine() */
@Test
public void combine() {
TupleDesc td1, td2, td3;
td1 = Utility.getTupleDesc(1, "td1");
td2 = Utility.getTupleDesc(2, "td2");
// test td1.combine(td2)
td3 = TupleDesc.merge(td1, td2);
assertEquals(3, td3.numFields());
assertEquals(3 * Type.INT_TYPE.getLen(), td3.getSize());
for (int i = 0; i < 3; ++i) assertEquals(Type.INT_TYPE, td3.getFieldType(i));
assertEquals(combinedStringArrays(td1, td2, td3), true);
// test td2.combine(td1)
td3 = TupleDesc.merge(td2, td1);
assertEquals(3, td3.numFields());
assertEquals(3 * Type.INT_TYPE.getLen(), td3.getSize());
for (int i = 0; i < 3; ++i) assertEquals(Type.INT_TYPE, td3.getFieldType(i));
assertEquals(combinedStringArrays(td2, td1, td3), true);
// test td2.combine(td2)
td3 = TupleDesc.merge(td2, td2);
assertEquals(4, td3.numFields());
assertEquals(4 * Type.INT_TYPE.getLen(), td3.getSize());
for (int i = 0; i < 4; ++i) assertEquals(Type.INT_TYPE, td3.getFieldType(i));
assertEquals(combinedStringArrays(td2, td2, td3), true);
}
/**
* Create a new TableStats object, that keeps track of statistics on each column of a table
*
* @param tableid The table over which to compute statistics
* @param ioCostPerPage The cost per page of IO. This doesn't differentiate between
* sequential-scan IO and disk seeks.
*/
public TableStats(int tableid, int ioCostPerPage) {
// For this function, we use the DbFile for the table in question,
// then scan through its tuples and calculate the values that you
// to build the histograms.
// TODO: Fill out the rest of the constructor.
// Feel free to change anything already written, it's only a guideline
this.ioCostPerPage = ioCostPerPage;
DbFile file = Database.getCatalog().getDbFile(tableid);
tupleDesc = file.getTupleDesc();
numPages = ((HeapFile) file).numPages();
numTuples = 0;
int numFields = tupleDesc.numFields();
// TODO: what goes here?
statistics = new ArrayList<Object>();
for (int i = 0; i < numFields; i++) {
if (Type.INT_TYPE.equals(tupleDesc.getFieldType(i))) {
statistics.add(new IntStatistics(NUM_HIST_BINS));
} else {
statistics.add(new StringHistogram(NUM_HIST_BINS));
}
}
final DbFileIterator iter = file.iterator(null);
try {
iter.open();
while (iter.hasNext()) {
Tuple t = iter.next();
numTuples++;
// TODO: and here?
for (int i = 0; i < numFields; i++) {
if (Type.INT_TYPE.equals(tupleDesc.getFieldType(i))) {
((IntStatistics) statistics.get(i)).addValue(((IntField) t.getField(i)).getValue());
} else {
((StringHistogram) statistics.get(i))
.addValue(((StringField) t.getField(i)).getValue());
}
}
}
iter.close();
} catch (DbException e) {
e.printStackTrace();
} catch (TransactionAbortedException e) {
e.printStackTrace();
}
}
// Test mix of INT_TYPE and STRING_TYPE.
@Test
public void new_getSizeTest() {
Type[] typeAr = new Type[] {Type.INT_TYPE, Type.INT_TYPE, Type.STRING_TYPE, Type.STRING_TYPE};
String[] fieldAr = new String[] {"number0", "number1", "string0", "string1"};
TupleDesc td = new TupleDesc(typeAr, fieldAr);
int length = 2 * Type.INT_TYPE.getLen() + 2 * Type.STRING_TYPE.getLen();
assertEquals(length, td.getSize());
}
/** Unit test for TupleDesc.getSize() */
@Test
public void getSize() {
int[] lengths = new int[] {1, 2, 1000};
for (int len : lengths) {
TupleDesc td = Utility.getTupleDesc(len);
assertEquals(len * Type.INT_TYPE.getLen(), td.getSize());
}
}
/**
* Estimate the selectivity of predicate <tt>field op constant</tt> on the table.
*
* @param field The field over which the predicate ranges
* @param op The logical operation in the predicate
* @param constant The value against which the field is compared
* @return The estimated selectivity (fraction of tuples that satisfy) the predicate
*/
public double estimateSelectivity(int field, Predicate.Op op, Field constant) {
// TODO: some code goes here
if (Type.INT_TYPE.equals(tupleDesc.getFieldType(field))) {
return ((IntStatistics) statistics.get(field))
.estimateSelectivity(op, ((IntField) constant).getValue());
} else {
return ((StringHistogram) statistics.get(field))
.estimateSelectivity(op, ((StringField) constant).getValue());
}
}
public static void generateMethodBody(
@NotNull MethodVisitor mv,
@NotNull FunctionDescriptor functionDescriptor,
@NotNull MethodContext context,
@NotNull JvmMethodSignature signature,
@NotNull FunctionGenerationStrategy strategy,
@NotNull MemberCodegen<?> parentCodegen) {
mv.visitCode();
Label methodBegin = new Label();
mv.visitLabel(methodBegin);
JetTypeMapper typeMapper = parentCodegen.typeMapper;
if (BuiltinSpecialBridgesUtil.shouldHaveTypeSafeBarrier(
functionDescriptor, getSignatureMapper(typeMapper))) {
generateTypeCheckBarrierIfNeeded(
new InstructionAdapter(mv),
functionDescriptor,
signature.getReturnType(),
/* delegateParameterType = */ null);
}
Label methodEnd;
int functionFakeIndex = -1;
int lambdaFakeIndex = -1;
if (context.getParentContext() instanceof MultifileClassFacadeContext) {
generateFacadeDelegateMethodBody(
mv, signature.getAsmMethod(), (MultifileClassFacadeContext) context.getParentContext());
methodEnd = new Label();
} else {
FrameMap frameMap =
createFrameMap(
parentCodegen.state,
functionDescriptor,
signature,
isStaticMethod(context.getContextKind(), functionDescriptor));
if (context.isInlineMethodContext()) {
functionFakeIndex = frameMap.enterTemp(Type.INT_TYPE);
}
if (context instanceof InlineLambdaContext) {
lambdaFakeIndex = frameMap.enterTemp(Type.INT_TYPE);
}
Label methodEntry = new Label();
mv.visitLabel(methodEntry);
context.setMethodStartLabel(methodEntry);
if (!JetTypeMapper.isAccessor(functionDescriptor)) {
genNotNullAssertionsForParameters(
new InstructionAdapter(mv), parentCodegen.state, functionDescriptor, frameMap);
}
methodEnd = new Label();
context.setMethodEndLabel(methodEnd);
strategy.generateBody(mv, frameMap, signature, context, parentCodegen);
}
mv.visitLabel(methodEnd);
Type thisType = getThisTypeForFunction(functionDescriptor, context, typeMapper);
generateLocalVariableTable(
mv,
signature,
functionDescriptor,
thisType,
methodBegin,
methodEnd,
context.getContextKind());
if (context.isInlineMethodContext() && functionFakeIndex != -1) {
mv.visitLocalVariable(
JvmAbi.LOCAL_VARIABLE_NAME_PREFIX_INLINE_FUNCTION
+ functionDescriptor.getName().asString(),
Type.INT_TYPE.getDescriptor(),
null,
methodBegin,
methodEnd,
functionFakeIndex);
}
if (context instanceof InlineLambdaContext && thisType != null && lambdaFakeIndex != -1) {
String name = thisType.getClassName();
int indexOfLambdaOrdinal = name.lastIndexOf("$");
if (indexOfLambdaOrdinal > 0) {
int lambdaOrdinal = Integer.parseInt(name.substring(indexOfLambdaOrdinal + 1));
mv.visitLocalVariable(
JvmAbi.LOCAL_VARIABLE_NAME_PREFIX_INLINE_ARGUMENT + lambdaOrdinal,
Type.INT_TYPE.getDescriptor(),
null,
methodBegin,
methodEnd,
lambdaFakeIndex);
}
}
}