@Override public void process(Object row, int tag) throws HiveException { rowCount++; Object[] resultObjectArray = new Object[columnSize]; if (row instanceof ArrayList) { List<Object> rowObjectList = (ArrayList<Object>) row; for (int c = 0; c < columnSize; c++) { resultObjectArray[c] = ((PrimitiveObjectInspector) outputObjectInspectors[c]).copyObject(rowObjectList.get(c)); } } else { Object[] rowObjectArray = (Object[]) row; for (int c = 0; c < columnSize; c++) { resultObjectArray[c] = ((PrimitiveObjectInspector) outputObjectInspectors[c]).copyObject(rowObjectArray[c]); } } nextTestRow(new RowTestObjects(resultObjectArray)); }
private RowTestObjects getTestKey(VectorizedRowBatch bigTableBatch, int batchIndex, VectorExtractRow vectorExtractRow, int columnCount, ObjectInspector[] objectInspectors) { Object[] rowObjects = new Object[columnCount]; vectorExtractRow.extractRow(bigTableBatch, batchIndex, rowObjects); for (int c = 0; c < rowObjects.length; c++) { rowObjects[c] = ((PrimitiveObjectInspector) objectInspectors[c]).copyObject(rowObjects[c]); } return new RowTestObjects(rowObjects); }
private void addToOutput(MapJoinTestDescription testDesc, RowTestObjectsMultiSet expectedTestRowMultiSet, Object[] outputObjects, RowTestObjectsMultiSet.RowFlag rowFlag) { for (int c = 0; c < outputObjects.length; c++) { PrimitiveObjectInspector primitiveObjInsp = ((PrimitiveObjectInspector) testDesc.outputObjectInspectors[c]); Object outputObject = outputObjects[c]; outputObjects[c] = primitiveObjInsp.copyObject(outputObject); } expectedTestRowMultiSet.add(new RowTestObjects(outputObjects), rowFlag); }
private static RowTestObjects generateRandomSmallTableValueRow(MapJoinTestDescription testDesc, Random random) { final int columnCount = testDesc.smallTableValueTypeInfos.length; PrimitiveTypeInfo[] primitiveTypeInfos = new PrimitiveTypeInfo[columnCount]; for (int i = 0; i < columnCount; i++) { primitiveTypeInfos[i] = (PrimitiveTypeInfo) testDesc.smallTableValueTypeInfos[i]; } Object[] smallTableValueRow = VectorRandomRowSource.randomWritablePrimitiveRow( columnCount, random, primitiveTypeInfos); for (int c = 0; c < smallTableValueRow.length; c++) { smallTableValueRow[c] = ((PrimitiveObjectInspector) testDesc.smallTableValueObjectInspectors[c]).copyObject(smallTableValueRow[c]); } return new RowTestObjects(smallTableValueRow); }
@Override public void process(Object row, int tag) throws HiveException { VectorizedRowBatch batch = (VectorizedRowBatch) row; rowCount += batch.size; boolean selectedInUse = batch.selectedInUse; int[] selected = batch.selected; for (int logical = 0; logical < batch.size; logical++) { int batchIndex = (selectedInUse ? selected[logical] : logical); Object[] rowObjects = new Object[outputObjectInspectors.length]; vectorExtractRow.extractRow(batch, batchIndex, rowObjects); for (int c = 0; c < rowObjects.length; c++) { rowObjects[c] = ((PrimitiveObjectInspector) outputObjectInspectors[c]).copyObject(rowObjects[c]); } nextTestRow(new RowTestObjects(rowObjects)); } }
result = loi.getPrimitiveWritableObject(loi.copyObject(o)); break;
case PRIMITIVE: rowObjects[c] = ((PrimitiveObjectInspector) outputObjectInspectors[c]).copyObject( rowObjects[c]); break; if (oldValue != null) { newValue = ((PrimitiveObjectInspector) structField.getFieldObjectInspector()).copyObject( oldValue); } else {
bigTableKeyObjects[k] = ((PrimitiveObjectInspector) testDesc.bigTableObjectInspectors[keyColumnNum]).copyObject(bigTableKeyObjects[k]);
public void addValue(Object keyObj, Object valObj) { if (sortedValues.size() < numValues) { SortedKeyValue newValue = new SortedKeyValue(inputKeyOI.copyObject(keyObj), inputValOI.copyObject(valObj)); sortedValues.add(newValue); } else { SortedKeyValue minValue = sortedValues.last(); SortedKeyValue biggerValue = new SortedKeyValue(inputKeyOI.copyObject(keyObj), inputValOI.copyObject(valObj)); int cmp = biggerValue.compareTo(minValue); if (cmp < 0) { sortedValues.remove(minValue); sortedValues.add(biggerValue); } } }
public static Object[][] generateRowObjectArray(TypeInfo[] typeInfos, VectorBatchGenerateStream batchStream, VectorizedRowBatch batch, ObjectInspector[] objectInspectors) throws HiveException { VectorExtractRow vectorExtractRow = new VectorExtractRow(); vectorExtractRow.init(typeInfos); final int rowCount = batchStream.getRowCount(); final int columnCount = typeInfos.length; Object[][] rowObjectArray = new Object[rowCount][]; Object[] row = new Object[columnCount]; int index = 0; batchStream.reset(); while (batchStream.isNext()) { batch.reset(); batchStream.fillNext(batch); // Extract rows and call process per row final int size = batch.size; for (int r = 0; r < size; r++) { vectorExtractRow.extractRow(batch, r, row); Object[] resultObjectArray = new Object[columnCount]; for (int c = 0; c < columnCount; c++) { resultObjectArray[c] = ((PrimitiveObjectInspector) objectInspectors[c]).copyObject(row[c]); } rowObjectArray[index++] = resultObjectArray; } } return rowObjectArray; }
private Map<Object, Object> gets(Object argKeys, Object argValues) throws HiveException { final List<?> keys = keysInputOI.getList(argKeys); final List<?> defaultValues = valuesInputOI.getList(argValues); final int numKeys = keys.size(); if(numKeys != defaultValues.size()) { throw new HiveException("# of default values != # of lookup keys: keys " + argKeys + ", values: " + argValues); } final Map<Object, Object> map = new HashMap<Object, Object>(); for(int i = 0; i < numKeys; i++) { Object k = keys.get(i); if(k == null) { continue; } Object kj = keyInputOI.getPrimitiveJavaObject(k); Object v = cache.get(lookupKey(kj)); if(v == null) { v = defaultValues.get(i); if(v != null) { v = valueInputOI.getPrimitiveWritableObject(valueInputOI.copyObject(v)); } } map.put(k, v); } return map; }
private Map<Object, Object> gets(Object argKeys, Object argValues) throws HiveException { final List<?> keys = keysInputOI.getList(argKeys); final List<?> defaultValues = valuesInputOI.getList(argValues); final int numKeys = keys.size(); if (numKeys != defaultValues.size()) { throw new HiveException("# of default values != # of lookup keys: keys " + argKeys + ", values: " + argValues); } final Map<Object, Object> map = new HashMap<Object, Object>(); for (int i = 0; i < numKeys; i++) { Object k = keys.get(i); if (k == null) { continue; } Object kj = keyInputOI.getPrimitiveJavaObject(k); Object v = cache.get(lookupKey(kj)); if (v == null) { v = defaultValues.get(i); if (v != null) { v = valueInputOI.getPrimitiveWritableObject(valueInputOI.copyObject(v)); } } map.put(k, v); } return map; }
private Map<Object, Object> gets(Object argKeys, Object argValues) throws HiveException { final List<?> keys = keysInputOI.getList(argKeys); final List<?> defaultValues = valuesInputOI.getList(argValues); final int numKeys = keys.size(); if (numKeys != defaultValues.size()) { throw new HiveException("# of default values != # of lookup keys: keys " + argKeys + ", values: " + argValues); } final Map<Object, Object> map = new HashMap<Object, Object>(); for (int i = 0; i < numKeys; i++) { Object k = keys.get(i); if (k == null) { continue; } Object kj = keyInputOI.getPrimitiveJavaObject(k); Object v = cache.get(lookupKey(kj)); if (v == null) { v = defaultValues.get(i); if (v != null) { v = valueInputOI.getPrimitiveWritableObject(valueInputOI.copyObject(v)); } } map.put(k, v); } return map; }
Object f1 = fields.get(1); Object k = keyRefOI.getPrimitiveJavaObject(f0); Object v = valueRefOI.getPrimitiveWritableObject(valueRefOI.copyObject(f1)); map.put(k, v);
Object f1 = fields.get(1); Object k = keyRefOI.getPrimitiveJavaObject(f0); Object v = valueRefOI.getPrimitiveWritableObject(valueRefOI.copyObject(f1)); map.put(k, v);
Object f1 = fields.get(1); Object k = keyRefOI.getPrimitiveJavaObject(f0); Object v = valueRefOI.getPrimitiveWritableObject(valueRefOI.copyObject(f1)); map.put(k, v);
continue; // avoid the case that key or value is null Object label = c1refOI.getPrimitiveWritableObject(c1refOI.copyObject(f0)); PredictionModel model = label2model.get(label); if (model == null) { label2model.put(label, model); Object k = c2refOI.getPrimitiveWritableObject(c2refOI.copyObject(f1)); float v = c3refOI.get(f2); model.set(k, new WeightValue(v, false));
continue; // avoid the case that key or value is null Object k = keyRefOI.getPrimitiveWritableObject(keyRefOI.copyObject(f0)); float v = varRefOI.get(f1); model.set(k, new WeightValue(v, false));
continue; // avoid the case that key or value is null Object k = keyRefOI.getPrimitiveWritableObject(keyRefOI.copyObject(f0)); float v = varRefOI.get(f1); model.set(k, new WeightValue(v, false));
continue; // avoid unexpected case Object k = c1oi.getPrimitiveWritableObject(c1oi.copyObject(f0)); float v = c2oi.get(f1); float cov = (f2 == null) ? WeightValueWithCovar.DEFAULT_COVAR