congrats Icon
New! Announcing Tabnine Chat Beta
Learn More
Tabnine Logo
ATypeTag.isDerivedType
Code IndexAdd Tabnine to your IDE (free)

How to use
isDerivedType
method
in
org.apache.asterix.om.types.ATypeTag

Best Java code snippets using org.apache.asterix.om.types.ATypeTag.isDerivedType (Showing top 20 results out of 315)

origin: apache/asterixdb

private boolean hasDerivedType(IAType[] types) {
  for (IAType type : types) {
    if (type.getTypeTag().isDerivedType()) {
      return true;
    }
  }
  return false;
}
origin: apache/asterixdb

private boolean hasDerivedType(IAType[] types) {
  for (IAType type : types) {
    if (type.getTypeTag().isDerivedType()) {
      return true;
    }
  }
  return false;
}
origin: apache/asterixdb

private boolean hasDerivedType(IAType[] types) {
  for (IAType type : types) {
    if (type.getTypeTag().isDerivedType()) {
      return true;
    }
  }
  return false;
}
origin: apache/asterixdb

private boolean hasDerivedType(IAType[] types) {
  for (IAType type : types) {
    if (type.getTypeTag().isDerivedType()) {
      return true;
    }
  }
  return false;
}
origin: apache/asterixdb

private boolean processOrderedList(List<IVisitablePointable> itemsLeft, List<IVisitablePointable> itemTagTypesLeft,
    List<IVisitablePointable> itemsRight, List<IVisitablePointable> itemTagTypesRight)
    throws HyracksDataException {
  for (int i = 0; i < itemsLeft.size(); i++) {
    ATypeTag fieldTypeLeft = PointableHelper.getTypeTag(itemTagTypesLeft.get(i));
    if (fieldTypeLeft.isDerivedType()
        && fieldTypeLeft != PointableHelper.getTypeTag(itemTagTypesRight.get(i))) {
      return false;
    }
    itemVisitorArg.first = itemsRight.get(i);
    itemsLeft.get(i).accept(visitor, itemVisitorArg);
    if (itemVisitorArg.second == false)
      return false;
  }
  return true;
}
origin: apache/asterixdb

public static Map<TypeSignature, IAType> computeTypes(MetadataTransactionContext mdTxnCtx, TypeExpression typeExpr,
    String typeName, String typeDataverse, Map<TypeSignature, IAType> typeMap) throws AlgebricksException {
  Map<String, Map<ARecordType, List<Integer>>> incompleteFieldTypes = new HashMap<>();
  Map<TypeSignature, List<AbstractCollectionType>> incompleteItemTypes = new HashMap<>();
  Map<TypeSignature, List<TypeSignature>> incompleteTopLevelTypeReferences = new HashMap<>();
  firstPass(typeExpr, typeName, typeMap, incompleteFieldTypes, incompleteItemTypes,
      incompleteTopLevelTypeReferences, typeDataverse);
  secondPass(mdTxnCtx, typeMap, incompleteFieldTypes, incompleteItemTypes, incompleteTopLevelTypeReferences,
      typeDataverse);
  for (IAType type : typeMap.values()) {
    if (type.getTypeTag().isDerivedType()) {
      ((AbstractComplexType) type).generateNestedDerivedTypeNames();
    }
  }
  return typeMap;
}
origin: apache/asterixdb

@Override
public void generateNestedDerivedTypeNames() {
  for (int i = 0; i < fieldTypes.length; i++) {
    IAType fieldType = fieldTypes[i];
    if (fieldType.getTypeTag().isDerivedType() && (fieldType.getTypeName() == null)) {
      AbstractComplexType nestedType = (AbstractComplexType) fieldType;
      nestedType.setTypeName(getTypeName() + "_" + fieldNames[i]);
      nestedType.generateNestedDerivedTypeNames();
    }
  }
}
origin: apache/asterixdb

@Override
public void generateNestedDerivedTypeNames() {
  if (itemType.getTypeTag().isDerivedType() && itemType.getTypeName() == null) {
    AbstractComplexType nestedType = ((AbstractComplexType) itemType);
    nestedType.setTypeName(getTypeName() + "_Item");
    nestedType.generateNestedDerivedTypeNames();
  }
}
origin: apache/asterixdb

  private boolean compareValues(List<IVisitablePointable> fieldTypesLeft, List<IVisitablePointable> fieldValuesLeft,
      List<IVisitablePointable> fieldNamesRight, List<IVisitablePointable> fieldTypesRight,
      List<IVisitablePointable> fieldValuesRight) throws HyracksDataException {

    // Probe phase: Probe items from second record
    for (int i = 0; i < fieldNamesRight.size(); i++) {
      IVisitablePointable fieldName = fieldNamesRight.get(i);
      keyEntry.set(fieldName.getByteArray(), fieldName.getStartOffset(), fieldName.getLength());
      BinaryEntry entry = hashMap.get(keyEntry);
      if (entry == null) {
        return false;
      }

      int fieldIdLeft = AInt32SerializerDeserializer.getInt(entry.getBuf(), entry.getOffset());
      ATypeTag fieldTypeLeft = PointableHelper.getTypeTag(fieldTypesLeft.get(fieldIdLeft));
      if (fieldTypeLeft.isDerivedType() && fieldTypeLeft != PointableHelper.getTypeTag(fieldTypesRight.get(i))) {
        return false;
      }
      nestedVisitorArg.first = fieldValuesRight.get(i);
      fieldValuesLeft.get(fieldIdLeft).accept(visitor, nestedVisitorArg);
      if (nestedVisitorArg.second == false) {
        return false;
      }
    }
    return true;
  }
}
origin: apache/asterixdb

if (fieldTypeLeft.isDerivedType()
    && fieldTypeLeft != PointableHelper.getTypeTag(itemTagTypesRight.get(indexRight))) {
  return false;
origin: apache/asterixdb

  @Override
  protected void processList(ListAccessor listAccessor, IAsterixListBuilder listBuilder) throws IOException {
    sortedList.clear();
    boolean itemInStorage;
    for (int i = 0; i < listAccessor.size(); i++) {
      itemInStorage = listAccessor.getOrWriteItem(i, item, storage);
      if (ATYPETAGDESERIALIZER.deserialize(item.getByteArray()[item.getStartOffset()]).isDerivedType()) {
        throw new RuntimeDataException(ErrorCode.CANNOT_COMPARE_COMPLEX, sourceLoc);
      }
      sortedList.add(item);
      if (itemInStorage) {
        storage = (ArrayBackedValueStorage) storageAllocator.allocate(null);
      }
      item = pointableAllocator.allocateEmpty();
    }
    while (!sortedList.isEmpty()) {
      listBuilder.addItem(sortedList.poll());
    }
  }
}
origin: apache/asterixdb

private boolean validate(IAType type, IAdmNode node) {
  if (type.getTypeTag().isDerivedType()) {
    return validateDerivedType(type, node);
  } else if (node == null) {
    result = ErrorType.MISSING_UNOPTIONAL_FIELD;
    return false;
  } else if (type.getTypeTag() != node.getType()) {
    setExpectedAndActualType(type.getTypeTag(), node.getType());
    return false;
  }
  return true;
}
origin: apache/asterixdb

@Override
public void generateNestedDerivedTypeNames() {
  if (isUnknownableType()) {
    IAType nullableType = getActualType();
    if (nullableType.getTypeTag().isDerivedType() && nullableType.getTypeName() == null) {
      AbstractComplexType derivedType = (AbstractComplexType) nullableType;
      derivedType.setTypeName(getTypeName());
      derivedType.generateNestedDerivedTypeNames();
    }
  }
}
origin: apache/asterixdb

private ILogicalExpression translateConstantValue(IAObject value, SourceLocation sourceLoc)
    throws CompilationException {
  ConstantExpression constExpr = new ConstantExpression(new AsterixConstantValue(value));
  constExpr.setSourceLocation(sourceLoc);
  IAType valueType = value.getType();
  if (valueType.getTypeTag().isDerivedType()) {
    ScalarFunctionCallExpression castExpr =
        new ScalarFunctionCallExpression(FunctionUtil.getFunctionInfo(BuiltinFunctions.CAST_TYPE));
    castExpr.setSourceLocation(sourceLoc);
    castExpr.getArguments().add(new MutableObject<>(constExpr));
    TypeCastUtils.setRequiredAndInputTypes(castExpr, BuiltinType.ANY, valueType);
    return castExpr;
  } else {
    return constExpr;
  }
}
origin: apache/asterixdb

private void writeCollectionType(Datatype instance, AbstractComplexType type, DataOutput out)
    throws HyracksDataException {
  AbstractCollectionType listType = (AbstractCollectionType) type;
  IAType itemType = listType.getItemType();
  if (itemType.getTypeTag().isDerivedType()) {
    handleNestedDerivedType(itemType.getTypeName(), (AbstractComplexType) itemType, instance,
        instance.getDataverseName(), instance.getDatatypeName());
  }
  aString.setValue(listType.getItemType().getTypeName());
  stringSerde.serialize(aString, out);
}
origin: apache/asterixdb

  return listValueAllocator.allocate(DefaultOpenFieldType.NESTED_OPEN_AUNORDERED_LIST_TYPE);
else {
  if (listItemType.isDerivedType())
    return allocateFieldValue(listItemType, b, offset + 1);
  else
  return listValueAllocator.allocate(DefaultOpenFieldType.NESTED_OPEN_AORDERED_LIST_TYPE);
else {
  if (listItemType.isDerivedType())
    return allocateFieldValue(listItemType, b, offset + 1);
  else
origin: apache/asterixdb

  return;
if (oldValueType.isDerivedType()) {
  throw new TypeMismatchException(sourceLoc, BuiltinFunctions.RECORD_REPLACE, 1, oldValueType.serialize(),
      "primitive");
if (newValueType.isDerivedType()) {
  newValueRecordCaster.evaluate(tuple, newValuePointable);
origin: apache/asterixdb

@Override
public void evaluate(IFrameTupleReference tuple, IPointable result) throws HyracksDataException {
  resultStorage.reset();
  eval0.evaluate(tuple, inputRecordPointable);
  eval1.evaluate(tuple, newFieldNamePointable);
  eval2.evaluate(tuple, newFieldValuePointable);
  if (containsMissing(inputRecordPointable, newFieldNamePointable)) {
    writeTypeTag(ATypeTag.SERIALIZED_MISSING_TYPE_TAG);
    result.set(resultStorage);
    return;
  }
  final ATypeTag inputObjectType = PointableHelper.getTypeTag(inputRecordPointable);
  final ATypeTag newFieldNameValueType = PointableHelper.getTypeTag(newFieldNamePointable);
  if (inputObjectType != ATypeTag.OBJECT || newFieldNameValueType != ATypeTag.STRING) {
    PointableHelper.setNull(result);
    return;
  }
  inputRecordCaster.evaluate(tuple, inputRecordPointable);
  final ATypeTag newFieldValueTag = PointableHelper.getTypeTag(newFieldValuePointable);
  if (newFieldValueTag.isDerivedType()) {
    argRecordCaster.evaluate(tuple, newFieldValuePointable);
  }
  newFieldValueIsMissing = newFieldValueTag == ATypeTag.MISSING;
  buildOutputRecord();
  result.set(resultStorage);
}
origin: apache/asterixdb

private void processLists(IPointable[] listsArgs, IAsterixListBuilder listBuilder) throws IOException {
  boolean itemInStorage;
  boolean isUsingItem;
  IPointable item = pointableAllocator.allocateEmpty();
  ArrayBackedValueStorage storage = (ArrayBackedValueStorage) storageAllocator.allocate(null);
  storage.reset();
  // process each list one by one
  for (int listIndex = 0; listIndex < listsArgs.length; listIndex++) {
    listAccessor.reset(listsArgs[listIndex].getByteArray(), listsArgs[listIndex].getStartOffset());
    // process the items of the current list
    for (int j = 0; j < listAccessor.size(); j++) {
      itemInStorage = listAccessor.getOrWriteItem(j, item, storage);
      if (ATYPETAGDESERIALIZER.deserialize(item.getByteArray()[item.getStartOffset()]).isDerivedType()
          && isComparingElements) {
        throw new RuntimeDataException(ErrorCode.CANNOT_COMPARE_COMPLEX, sourceLocation);
      }
      isUsingItem = processItem(item, listIndex, listBuilder);
      if (isUsingItem) {
        item = pointableAllocator.allocateEmpty();
        if (itemInStorage) {
          storage = (ArrayBackedValueStorage) storageAllocator.allocate(null);
          storage.reset();
        }
      }
    }
  }
}
origin: apache/asterixdb

private void processList(ListAccessor listAccessor, int listIndex, IAsterixListBuilder listBuilder,
    boolean initIntersectList) throws IOException {
  int hash;
  List<ValueListIndex> sameHashes;
  boolean itemInStorage;
  IPointable item = pointableAllocator.allocateEmpty();
  ArrayBackedValueStorage storage = (ArrayBackedValueStorage) storageAllocator.allocate(null);
  storage.reset();
  for (int j = 0; j < listAccessor.size(); j++) {
    itemInStorage = listAccessor.getOrWriteItem(j, item, storage);
    if (ATYPETAGDESERIALIZER.deserialize(item.getByteArray()[item.getStartOffset()]).isDerivedType()) {
      throw new RuntimeDataException(ErrorCode.CANNOT_COMPARE_COMPLEX, sourceLoc);
    }
    if (notNullAndMissing(item)) {
      // look up to see if item exists
      hash = binaryHashFunction.hash(item.getByteArray(), item.getStartOffset(), item.getLength());
      sameHashes = hashes.get(hash);
      if (initIntersectList && initIntersectList(item, hash, sameHashes)) {
        // item is used
        item = pointableAllocator.allocateEmpty();
        if (itemInStorage) {
          storage = (ArrayBackedValueStorage) storageAllocator.allocate(null);
          storage.reset();
        }
      } else {
        incrementCommonValue(item, sameHashes, listIndex, listBuilder);
      }
    }
  }
}
org.apache.asterix.om.typesATypeTagisDerivedType

Popular methods of ATypeTag

  • serialize
  • equals
  • ordinal
  • isListType
  • toString
  • hashCode
  • name
  • values

Popular in Java

  • Reactive rest calls using spring rest template
  • putExtra (Intent)
  • getOriginalFilename (MultipartFile)
    Return the original filename in the client's filesystem.This may contain path information depending
  • setScale (BigDecimal)
  • Rectangle (java.awt)
    A Rectangle specifies an area in a coordinate space that is enclosed by the Rectangle object's top-
  • DateFormat (java.text)
    Formats or parses dates and times.This class provides factories for obtaining instances configured f
  • Calendar (java.util)
    Calendar is an abstract base class for converting between a Date object and a set of integer fields
  • Comparator (java.util)
    A Comparator is used to compare two objects to determine their ordering with respect to each other.
  • Date (java.util)
    A specific moment in time, with millisecond precision. Values typically come from System#currentTime
  • JList (javax.swing)
  • Best plugins for Eclipse
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now