/**
* This runtime function checks if the input is null. If the input is not null, just return it
* directly; Otherwise, throw a runtime exception.
*/
public class NotNullDescriptor extends AbstractScalarFunctionDynamicDescriptor {
private static final long serialVersionUID = 1L;
public static final IFunctionDescriptorFactory FACTORY =
new IFunctionDescriptorFactory() {
public IFunctionDescriptor createFunctionDescriptor() {
return new NotNullDescriptor();
}
};
private static final byte SER_NULL_TYPE_TAG = ATypeTag.NULL.serialize();
@Override
public ICopyEvaluatorFactory createEvaluatorFactory(final ICopyEvaluatorFactory[] args) {
return new ICopyEvaluatorFactory() {
private static final long serialVersionUID = 1L;
@Override
public ICopyEvaluator createEvaluator(final IDataOutputProvider output)
throws AlgebricksException {
return new ICopyEvaluator() {
private DataOutput out = output.getDataOutput();
private ArrayBackedValueStorage outInput = new ArrayBackedValueStorage();
private ICopyEvaluator eval = args[0].createEvaluator(outInput);
private String errorMessage =
AsterixBuiltinFunctions.NOT_NULL + ": the input value cannot be NULL.";
@Override
public void evaluate(IFrameTupleReference tuple) throws AlgebricksException {
try {
outInput.reset();
eval.evaluate(tuple);
byte[] data = outInput.getByteArray();
if (data[outInput.getStartOffset()] == SER_NULL_TYPE_TAG) {
throw new AlgebricksException(errorMessage);
}
out.write(data, outInput.getStartOffset(), outInput.getLength());
} catch (IOException e1) {
throw new AlgebricksException(errorMessage);
}
}
};
}
};
}
@Override
public FunctionIdentifier getIdentifier() {
return AsterixBuiltinFunctions.NOT_NULL;
}
}
protected void finishPartialResults() throws AlgebricksException {
try {
// Double check that count 0 is accounted
if (aggType == ATypeTag.SYSTEM_NULL) {
if (GlobalConfig.DEBUG) {
GlobalConfig.ASTERIX_LOGGER.finest("AVG aggregate ran over empty input.");
}
out.writeByte(ATypeTag.SYSTEM_NULL.serialize());
} else if (aggType == ATypeTag.NULL) {
out.writeByte(ATypeTag.NULL.serialize());
} else {
sumBytes.reset();
aDouble.setValue(sum);
doubleSerde.serialize(aDouble, sumBytesOutput);
countBytes.reset();
aInt64.setValue(count);
longSerde.serialize(aInt64, countBytesOutput);
recordEval.evaluate(null);
}
} catch (IOException e) {
throw new AlgebricksException(e);
}
}
public abstract class AbstractTripleStringStringEval implements ICopyEvaluator {
private DataOutput dout;
private static final byte SER_NULL_TYPE_TAG = ATypeTag.NULL.serialize();
private static final byte SER_STRING_TYPE_TAG = ATypeTag.STRING.serialize();
private ArrayBackedValueStorage array0 = new ArrayBackedValueStorage();
private ArrayBackedValueStorage array1 = new ArrayBackedValueStorage();
private ArrayBackedValueStorage array2 = new ArrayBackedValueStorage();
private ICopyEvaluator eval0;
private ICopyEvaluator eval1;
private ICopyEvaluator eval2;
private AMutableString resultBuffer = new AMutableString("");
@SuppressWarnings("rawtypes")
private ISerializerDeserializer nullSerde =
AqlSerializerDeserializerProvider.INSTANCE.getSerializerDeserializer(BuiltinType.ANULL);
@SuppressWarnings("rawtypes")
private ISerializerDeserializer strSerde =
AqlSerializerDeserializerProvider.INSTANCE.getSerializerDeserializer(BuiltinType.ASTRING);
private final UTF8StringPointable strPtr1st = new UTF8StringPointable();
private final UTF8StringPointable strPtr2nd = new UTF8StringPointable();
private final UTF8StringPointable strPtr3rd = new UTF8StringPointable();
private final FunctionIdentifier funcID;
public AbstractTripleStringStringEval(
DataOutput dout,
ICopyEvaluatorFactory eval0,
ICopyEvaluatorFactory eval1,
ICopyEvaluatorFactory eval2,
FunctionIdentifier funcID)
throws AlgebricksException {
this.dout = dout;
this.eval0 = eval0.createEvaluator(array0);
this.eval1 = eval1.createEvaluator(array1);
this.eval2 = eval2.createEvaluator(array2);
this.funcID = funcID;
}
@SuppressWarnings("unchecked")
@Override
public void evaluate(IFrameTupleReference tuple) throws AlgebricksException {
array0.reset();
eval0.evaluate(tuple);
array1.reset();
eval1.evaluate(tuple);
array2.reset();
eval2.evaluate(tuple);
try {
if (array0.getByteArray()[0] == SER_NULL_TYPE_TAG
|| array1.getByteArray()[0] == SER_NULL_TYPE_TAG
|| array2.getByteArray()[0] == SER_NULL_TYPE_TAG) {
nullSerde.serialize(ANull.NULL, dout);
return;
} else if (array0.getByteArray()[0] != SER_STRING_TYPE_TAG
|| array1.getByteArray()[0] != SER_STRING_TYPE_TAG
|| array2.getByteArray()[0] != SER_STRING_TYPE_TAG) {
throw new AlgebricksException(
funcID.getName()
+ ": expects input type (STRING/NULL, STRING/NULL, STRING/NULL), but got ("
+ EnumDeserializer.ATYPETAGDESERIALIZER.deserialize(array0.getByteArray()[0])
+ ", "
+ EnumDeserializer.ATYPETAGDESERIALIZER.deserialize(array1.getByteArray()[0])
+ ", "
+ EnumDeserializer.ATYPETAGDESERIALIZER.deserialize(array2.getByteArray()[0])
+ ".");
}
} catch (HyracksDataException e) {
throw new AlgebricksException(e);
}
strPtr1st.set(array0.getByteArray(), array0.getStartOffset() + 1, array0.getLength());
strPtr2nd.set(array1.getByteArray(), array1.getStartOffset() + 1, array1.getLength());
strPtr3rd.set(array2.getByteArray(), array2.getStartOffset() + 1, array2.getLength());
String res = compute(strPtr1st, strPtr2nd, strPtr3rd);
resultBuffer.setValue(res);
try {
strSerde.serialize(resultBuffer, dout);
} catch (HyracksDataException e) {
throw new AlgebricksException(e);
}
}
protected abstract String compute(
UTF8StringPointable strPtr1st, UTF8StringPointable strPtr2nd, UTF8StringPointable strPtr3rd)
throws AlgebricksException;
}
public class ParseTimeDescriptor extends AbstractScalarFunctionDynamicDescriptor {
private static final long serialVersionUID = 1L;
public static final FunctionIdentifier FID = AsterixBuiltinFunctions.PARSE_TIME;
private static final byte SER_STRING_TYPE_TAG = ATypeTag.STRING.serialize();
private static final byte SER_NULL_TYPE_TAG = ATypeTag.NULL.serialize();
private static final DateTimeFormatUtils DT_UTILS = DateTimeFormatUtils.getInstance();
public static final IFunctionDescriptorFactory FACTORY =
new IFunctionDescriptorFactory() {
@Override
public IFunctionDescriptor createFunctionDescriptor() {
return new ParseTimeDescriptor();
}
};
@Override
public ICopyEvaluatorFactory createEvaluatorFactory(final ICopyEvaluatorFactory[] args)
throws AlgebricksException {
return new ICopyEvaluatorFactory() {
private static final long serialVersionUID = 1L;
@Override
public ICopyEvaluator createEvaluator(final IDataOutputProvider output)
throws AlgebricksException {
return new ICopyEvaluator() {
private DataOutput out = output.getDataOutput();
private ArrayBackedValueStorage argOut0 = new ArrayBackedValueStorage();
private ArrayBackedValueStorage argOut1 = new ArrayBackedValueStorage();
private ICopyEvaluator eval0 = args[0].createEvaluator(argOut0);
private ICopyEvaluator eval1 = args[1].createEvaluator(argOut1);
@SuppressWarnings("unchecked")
private ISerializerDeserializer<ANull> nullSerde =
AqlSerializerDeserializerProvider.INSTANCE.getSerializerDeserializer(
BuiltinType.ANULL);
@SuppressWarnings("unchecked")
private ISerializerDeserializer<ATime> timeSerde =
AqlSerializerDeserializerProvider.INSTANCE.getSerializerDeserializer(
BuiltinType.ATIME);
private AMutableTime aTime = new AMutableTime(0);
private final UTF8StringPointable utf8Ptr = new UTF8StringPointable();
@Override
public void evaluate(IFrameTupleReference tuple) throws AlgebricksException {
argOut0.reset();
eval0.evaluate(tuple);
argOut1.reset();
eval1.evaluate(tuple);
try {
if (argOut0.getByteArray()[0] == SER_NULL_TYPE_TAG
|| argOut1.getByteArray()[0] == SER_NULL_TYPE_TAG) {
nullSerde.serialize(ANull.NULL, out);
return;
}
if (argOut0.getByteArray()[0] != SER_STRING_TYPE_TAG
|| argOut1.getByteArray()[0] != SER_STRING_TYPE_TAG) {
throw new AlgebricksException(
getIdentifier().getName()
+ ": expects two strings but got ("
+ EnumDeserializer.ATYPETAGDESERIALIZER.deserialize(
argOut0.getByteArray()[0])
+ ", "
+ EnumDeserializer.ATYPETAGDESERIALIZER.deserialize(
argOut1.getByteArray()[0])
+ ")");
}
utf8Ptr.set(argOut0.getByteArray(), 1, argOut0.getLength() - 1);
int start0 = utf8Ptr.getCharStartOffset();
int length0 = utf8Ptr.getUTF8Length();
utf8Ptr.set(argOut1.getByteArray(), 1, argOut1.getLength() - 1);
int start1 = utf8Ptr.getCharStartOffset();
int length1 = utf8Ptr.getUTF8Length();
long chronon = 0;
int formatStart = start1;
int formatLength = 0;
boolean processSuccessfully = false;
while (!processSuccessfully && formatStart < start1 + length1) {
// search for "|"
formatLength = 0;
for (; formatStart + formatLength < start1 + length1; formatLength++) {
if (argOut1.getByteArray()[formatStart + formatLength] == '|') {
break;
}
}
try {
chronon =
DT_UTILS.parseDateTime(
argOut0.getByteArray(),
start0,
length0,
argOut1.getByteArray(),
formatStart,
formatLength,
DateTimeParseMode.TIME_ONLY);
} catch (AsterixTemporalTypeParseException ex) {
formatStart += formatLength + 1;
continue;
}
processSuccessfully = true;
}
if (!processSuccessfully) {
throw new HyracksDataException(
"parse-date: Failed to match with any given format string!");
}
aTime.setValue((int) chronon);
timeSerde.serialize(aTime, out);
} catch (HyracksDataException ex) {
throw new AlgebricksException(ex);
}
}
};
}
};
}
/* (non-Javadoc)
* @see org.apache.asterix.om.functions.AbstractFunctionDescriptor#getIdentifier()
*/
@Override
public FunctionIdentifier getIdentifier() {
return FID;
}
}
public class StringUpperCaseDescriptor extends AbstractScalarFunctionDynamicDescriptor {
private static final long serialVersionUID = 1L;
public static final IFunctionDescriptorFactory FACTORY =
new IFunctionDescriptorFactory() {
public IFunctionDescriptor createFunctionDescriptor() {
return new StringUpperCaseDescriptor();
}
};
private static final byte SER_STRING_TYPE_TAG = ATypeTag.STRING.serialize();
private static final byte SER_NULL_TYPE_TAG = ATypeTag.NULL.serialize();
@Override
public ICopyEvaluatorFactory createEvaluatorFactory(final ICopyEvaluatorFactory[] args) {
return new ICopyEvaluatorFactory() {
private static final long serialVersionUID = 1L;
@Override
public ICopyEvaluator createEvaluator(final IDataOutputProvider output)
throws AlgebricksException {
return new ICopyEvaluator() {
private DataOutput out = output.getDataOutput();
private ArrayBackedValueStorage outInput = new ArrayBackedValueStorage();
private ICopyEvaluator eval = args[0].createEvaluator(outInput);
private final byte stt = ATypeTag.STRING.serialize();
private final GrowableArray array = new GrowableArray();
private final UTF8StringBuilder builder = new UTF8StringBuilder();
private final UTF8StringPointable string = new UTF8StringPointable();
@SuppressWarnings("unchecked")
private ISerializerDeserializer<ANull> nullSerde =
AqlSerializerDeserializerProvider.INSTANCE.getSerializerDeserializer(
BuiltinType.ANULL);
@Override
public void evaluate(IFrameTupleReference tuple) throws AlgebricksException {
try {
outInput.reset();
eval.evaluate(tuple);
byte[] serString = outInput.getByteArray();
if (serString[0] == SER_STRING_TYPE_TAG) {
string.set(serString, 1, serString.length);
array.reset();
UTF8StringPointable.uppercase(string, builder, array);
out.writeByte(stt);
out.write(array.getByteArray(), 0, array.getLength());
} else if (serString[0] == SER_NULL_TYPE_TAG) nullSerde.serialize(ANull.NULL, out);
else
throw new AlgebricksException(
AsterixBuiltinFunctions.STRING_UPPERCASE.getName()
+ ": expects input type STRING/NULL but got "
+ EnumDeserializer.ATYPETAGDESERIALIZER.deserialize(serString[0]));
} catch (IOException e1) {
throw new AlgebricksException(e1);
}
}
};
}
};
}
@Override
public FunctionIdentifier getIdentifier() {
return AsterixBuiltinFunctions.STRING_UPPERCASE;
}
}
/**
* Creates new Matcher and Pattern objects each time the value of the pattern argument (the second
* argument) changes.
*/
public class RegExpDescriptor extends AbstractScalarFunctionDynamicDescriptor {
private static final long serialVersionUID = 1L;
// allowed input types
private static final byte SER_NULL_TYPE_TAG = ATypeTag.NULL.serialize();
private static final byte SER_STRING_TYPE_TAG = ATypeTag.STRING.serialize();
public static final IFunctionDescriptorFactory FACTORY =
new IFunctionDescriptorFactory() {
public IFunctionDescriptor createFunctionDescriptor() {
return new RegExpDescriptor();
}
};
@Override
public FunctionIdentifier getIdentifier() {
return AsterixBuiltinFunctions.REG_EXP;
}
@Override
public ICopyEvaluatorFactory createEvaluatorFactory(final ICopyEvaluatorFactory[] args)
throws AlgebricksException {
return new ICopyEvaluatorFactory() {
private static final long serialVersionUID = 1L;
@Override
public ICopyEvaluator createEvaluator(IDataOutputProvider output) throws AlgebricksException {
final DataOutput dout = output.getDataOutput();
return new ICopyEvaluator() {
private boolean first = true;
private ArrayBackedValueStorage array0 = new ArrayBackedValueStorage();
private ICopyEvaluator evalString = args[0].createEvaluator(array0);
private ICopyEvaluator evalPattern = args[1].createEvaluator(array0);
private ByteArrayAccessibleOutputStream lastPattern =
new ByteArrayAccessibleOutputStream();
private UTF8CharSequence carSeq = new UTF8CharSequence();
private UTF8StringPointable utf8Ptr = new UTF8StringPointable();
private IBinaryComparator strComp =
AqlBinaryComparatorFactoryProvider.INSTANCE
.getBinaryComparatorFactory(BuiltinType.ASTRING, true)
.createBinaryComparator();
@SuppressWarnings("unchecked")
private ISerializerDeserializer<AString> stringSerde =
AqlSerializerDeserializerProvider.INSTANCE.getSerializerDeserializer(
BuiltinType.ASTRING);
@SuppressWarnings("unchecked")
private ISerializerDeserializer<ABoolean> booleanSerde =
AqlSerializerDeserializerProvider.INSTANCE.getSerializerDeserializer(
BuiltinType.ABOOLEAN);
@SuppressWarnings("unchecked")
private ISerializerDeserializer<ANull> nullSerde =
AqlSerializerDeserializerProvider.INSTANCE.getSerializerDeserializer(
BuiltinType.ANULL);
private Matcher matcher;
private Pattern pattern;
@Override
public void evaluate(IFrameTupleReference tuple) throws AlgebricksException {
// evaluate the pattern first
try {
array0.reset();
evalPattern.evaluate(tuple);
if (array0.getByteArray()[0] == SER_NULL_TYPE_TAG) {
nullSerde.serialize(ANull.NULL, dout);
return;
}
if (array0.getByteArray()[0] != SER_STRING_TYPE_TAG) {
throw new AlgebricksException(
AsterixBuiltinFunctions.REG_EXP.getName()
+ ": expects type STRING/NULL for the first input argument but got "
+ EnumDeserializer.ATYPETAGDESERIALIZER.deserialize(
array0.getByteArray()[0]));
}
boolean newPattern = false;
if (first) {
first = false;
newPattern = true;
} else {
int c =
strComp.compare(
array0.getByteArray(),
array0.getStartOffset(),
array0.getLength(),
lastPattern.getByteArray(),
0,
lastPattern.size());
if (c != 0) {
newPattern = true;
}
}
if (newPattern) {
lastPattern.reset();
lastPattern.write(
array0.getByteArray(), array0.getStartOffset(), array0.getLength());
// ! object creation !
DataInputStream di =
new DataInputStream(new ByteArrayInputStream(lastPattern.getByteArray()));
AString strPattern = (AString) stringSerde.deserialize(di);
pattern = Pattern.compile(strPattern.getStringValue());
}
array0.reset();
evalString.evaluate(tuple);
if (array0.getByteArray()[0] == SER_NULL_TYPE_TAG) {
nullSerde.serialize(ANull.NULL, dout);
return;
}
if (array0.getByteArray()[0] != SER_STRING_TYPE_TAG) {
throw new AlgebricksException(
AsterixBuiltinFunctions.REG_EXP.getName()
+ ": expects type STRING/NULL for the second input argument but got "
+ EnumDeserializer.ATYPETAGDESERIALIZER.deserialize(
array0.getByteArray()[0]));
}
utf8Ptr.set(array0.getByteArray(), 1, array0.getLength() - 1);
carSeq.reset(utf8Ptr);
if (newPattern) {
matcher = pattern.matcher(carSeq);
} else {
matcher.reset(carSeq);
}
ABoolean res = (matcher.find(0)) ? ABoolean.TRUE : ABoolean.FALSE;
booleanSerde.serialize(res, dout);
} catch (HyracksDataException e) {
throw new AlgebricksException(e);
}
}
};
}
};
}
}
private void parseRecord(ARecordType recType, DataOutput out, Boolean datasetRec)
throws IOException, AsterixException, AdmLexerException {
ArrayBackedValueStorage fieldValueBuffer = getTempBuffer();
ArrayBackedValueStorage fieldNameBuffer = getTempBuffer();
IARecordBuilder recBuilder = getRecordBuilder();
BitSet nulls = null;
if (datasetRec) {
if (recType != null) {
nulls = new BitSet(recType.getFieldNames().length);
recBuilder.reset(recType);
} else {
recBuilder.reset(null);
}
} else if (recType != null) {
nulls = new BitSet(recType.getFieldNames().length);
recBuilder.reset(recType);
} else {
recBuilder.reset(null);
}
recBuilder.init();
int token;
boolean inRecord = true;
boolean expectingRecordField = false;
boolean first = true;
Boolean openRecordField = false;
int fieldId = 0;
IAType fieldType = null;
do {
token = admLexer.next();
switch (token) {
case AdmLexer.TOKEN_END_RECORD:
{
if (expectingRecordField) {
throw new ParseException("Found END_RECORD while expecting a record field.");
}
inRecord = false;
break;
}
case AdmLexer.TOKEN_STRING_LITERAL:
{
// we've read the name of the field
// now read the content
fieldNameBuffer.reset();
fieldValueBuffer.reset();
expectingRecordField = false;
if (recType != null) {
String fldName =
admLexer
.getLastTokenImage()
.substring(1, admLexer.getLastTokenImage().length() - 1);
fieldId = recBuilder.getFieldId(fldName);
if (fieldId < 0 && !recType.isOpen()) {
throw new ParseException("This record is closed, you can not add extra fields !!");
} else if (fieldId < 0 && recType.isOpen()) {
aStringFieldName.setValue(
admLexer
.getLastTokenImage()
.substring(1, admLexer.getLastTokenImage().length() - 1));
stringSerde.serialize(aStringFieldName, fieldNameBuffer.getDataOutput());
openRecordField = true;
fieldType = null;
} else {
// a closed field
nulls.set(fieldId);
fieldType = recType.getFieldTypes()[fieldId];
openRecordField = false;
}
} else {
aStringFieldName.setValue(
admLexer
.getLastTokenImage()
.substring(1, admLexer.getLastTokenImage().length() - 1));
stringSerde.serialize(aStringFieldName, fieldNameBuffer.getDataOutput());
openRecordField = true;
fieldType = null;
}
token = admLexer.next();
if (token != AdmLexer.TOKEN_COLON) {
throw new ParseException(
"Unexpected ADM token kind: "
+ AdmLexer.tokenKindToString(token)
+ " while expecting \":\".");
}
token = admLexer.next();
this.admFromLexerStream(token, fieldType, fieldValueBuffer.getDataOutput(), false);
if (openRecordField) {
if (fieldValueBuffer.getByteArray()[0] != ATypeTag.NULL.serialize()) {
recBuilder.addField(fieldNameBuffer, fieldValueBuffer);
}
} else if (NonTaggedFormatUtil.isOptional(recType)) {
if (fieldValueBuffer.getByteArray()[0] != ATypeTag.NULL.serialize()) {
recBuilder.addField(fieldId, fieldValueBuffer);
}
} else {
recBuilder.addField(fieldId, fieldValueBuffer);
}
break;
}
case AdmLexer.TOKEN_COMMA:
{
if (first) {
throw new ParseException("Found COMMA before any record field.");
}
if (expectingRecordField) {
throw new ParseException("Found COMMA while expecting a record field.");
}
expectingRecordField = true;
break;
}
default:
{
throw new ParseException(
"Unexpected ADM token kind: "
+ AdmLexer.tokenKindToString(token)
+ " while parsing record fields.");
}
}
first = false;
} while (inRecord);
if (recType != null) {
nullableFieldId = checkNullConstraints(recType, nulls);
if (nullableFieldId != -1) {
throw new ParseException(
"Field: " + recType.getFieldNames()[nullableFieldId] + " can not be null");
}
}
recBuilder.write(out, true);
}
