Java Code Examples for com.amazonaws.services.dynamodbv2.model.AttributeValue#getB()

public static TableColumnType columnTypeFromDynamoValue(AttributeValue typedValue) {
	if(typedValue.getB() != null) {
		return TableColumnType.bytea;
	} else if (typedValue.getBOOL() != null) {
		return TableColumnType.bool;
	} else if (typedValue.getBS() != null) {
		return TableColumnType.jsonb;
	} else if (typedValue.getL() != null) {
		return TableColumnType.jsonb;
	} else if (typedValue.getM() != null) {
		return TableColumnType.jsonb;
	} else if (typedValue.getN() != null) {
		return TableColumnType.numeric;
	} else if (typedValue.getNS() != null) {
		return TableColumnType.jsonb;
	} else if (typedValue.getS() != null) {
		return TableColumnType.text;
	} else if (typedValue.getSS() != null) {
		return TableColumnType.jsonb;
	} else {
		return TableColumnType.text;
	}
}
 

public static Object getValue(AttributeValue value) {
    if(value.getB() != null) {
        return value.getB();
    } else if (value.getS() != null){
        return value.getS();
    } else if (value.getBOOL() != null){
        return value.getBOOL();
    } else if (value.getBS() != null){
        return value.getBS();
    } else if (value.getL() != null){
        return value.getL();
    } else if (value.getM() != null){
        return value.getM();
    } else if (value.getN() != null){
        return value.getN();
    } else if (value.getNS() != null){
        return value.getNS();
    } else if (value.getSS() != null){
        return value.getSS();
    }
    return null;
}
 

public static BUnmarshaller getByteArrayBUnmarshaller() {
    return new BUnmarshaller() {

        @Override
        public Object unmarshall(final AttributeValue value) throws ParseException {
            final ByteBuffer byteBuffer = value.getB();
            byte[] bytes = null;
            if (byteBuffer.hasArray()) {
                bytes = byteBuffer.array();
            } else {
                bytes = new byte[byteBuffer.limit()];
                byteBuffer.get(bytes, 0, bytes.length);
            }
            return bytes;
        }
    };
}
 

public ImmutableAttributeValue(AttributeValue av) {
    s = av.getS();
    n = av.getN();
    b = av.getB() != null ? av.getB().array().clone() : null;
    ns = av.getNS() != null ? new ArrayList<String>(av.getNS()) : null;
    ss = av.getSS() != null ? new ArrayList<String>(av.getSS()) : null;
    bs = av.getBS() != null ? new ArrayList<byte[]>(av.getBS().size()) : null;
    
    if(av.getBS() != null) {
        for(ByteBuffer buf : av.getBS()) {
            if(buf != null) {
                bs.add(buf.array().clone());
            } else {
                bs.add(null);
            }
        }
    }
}
 

private Object getAttributeObject(ScalarAttributeType type, AttributeValue value) {
    //Note: only string, number, and binary are allowed for primary keys in dynamodb
    switch (type) {
        case N:
            return Double.parseDouble(value.getN());
        case S:
            return value.getS();
        case B:
            return value.getB();
        default:
            throw new IllegalStateException("Unknown dynamo scalar type: " + type);
    }
}
 

@Override
public void encode(AttributeValue value, OutputStream outStream) throws IOException {

  if (value.getS() != null) {
    StringUtf8Coder.of().encode(AttributeValueType.s.toString(), outStream);
    StringUtf8Coder.of().encode(value.getS(), outStream);
  } else if (value.getN() != null) {
    StringUtf8Coder.of().encode(AttributeValueType.n.toString(), outStream);
    StringUtf8Coder.of().encode(value.getN(), outStream);
  } else if (value.getBOOL() != null) {
    StringUtf8Coder.of().encode(AttributeValueType.bOOL.toString(), outStream);
    BooleanCoder.of().encode(value.getBOOL(), outStream);
  } else if (value.getB() != null) {
    StringUtf8Coder.of().encode(AttributeValueType.b.toString(), outStream);
    ByteArrayCoder.of().encode(convertToByteArray(value.getB()), outStream);
  } else if (value.getSS() != null) {
    StringUtf8Coder.of().encode(AttributeValueType.sS.toString(), outStream);
    LIST_STRING_CODER.encode(value.getSS(), outStream);
  } else if (value.getNS() != null) {
    StringUtf8Coder.of().encode(AttributeValueType.nS.toString(), outStream);
    LIST_STRING_CODER.encode(value.getNS(), outStream);
  } else if (value.getBS() != null) {
    StringUtf8Coder.of().encode(AttributeValueType.bS.toString(), outStream);
    LIST_BYTE_CODER.encode(convertToListByteArray(value.getBS()), outStream);
  } else if (value.getL() != null) {
    StringUtf8Coder.of().encode(AttributeValueType.l.toString(), outStream);
    LIST_ATTRIBUTE_CODER.encode(value.getL(), outStream);
  } else if (value.getM() != null) {
    StringUtf8Coder.of().encode(AttributeValueType.m.toString(), outStream);
    MAP_ATTRIBUTE_CODER.encode(value.getM(), outStream);
  } else if (value.getNULL() != null) {
    StringUtf8Coder.of().encode(AttributeValueType.nULLValue.toString(), outStream);
    BooleanCoder.of().encode(value.getNULL(), outStream);
  } else {
    throw new CoderException("Unknown Type");
  }
}
 

/**
 * Extracts relevant information from {@code context} and uses it to populate fields in
 * {@code kmsEc}. Subclass can override the default implementation to provide an alternative
 * encryption context in calls to KMS. Currently, the default implementation includes these fields:
 * <dl>
 * <dt>{@code HashKeyName}</dt>
 * <dd>{@code HashKeyValue}</dd>
 * <dt>{@code RangeKeyName}</dt>
 * <dd>{@code RangeKeyValue}</dd>
 * <dt>{@link #TABLE_NAME_EC_KEY}</dt>
 * <dd>{@code TableName}</dd>
 */
protected void populateKmsEcFromEc(EncryptionContext context, Map<String, String> kmsEc) {
    final String hashKeyName = context.getHashKeyName();
    if (hashKeyName != null) {
        final AttributeValue hashKey = context.getAttributeValues().get(hashKeyName);
        if (hashKey.getN() != null) {
            kmsEc.put(hashKeyName, hashKey.getN());
        } else if (hashKey.getS() != null) {
            kmsEc.put(hashKeyName, hashKey.getS());
        } else if (hashKey.getB() != null) {
            kmsEc.put(hashKeyName, Base64.encodeToString(toArray(hashKey.getB())));
        } else {
            throw new UnsupportedOperationException("DirectKmsMaterialProvider only supports String, Number, and Binary HashKeys");
        }
    }
    final String rangeKeyName = context.getRangeKeyName();
    if (rangeKeyName != null) {
        final AttributeValue rangeKey = context.getAttributeValues().get(rangeKeyName);
        if (rangeKey.getN() != null) {
            kmsEc.put(rangeKeyName, rangeKey.getN());
        } else if (rangeKey.getS() != null) {
            kmsEc.put(rangeKeyName, rangeKey.getS());
        } else if (rangeKey.getB() != null) {
            kmsEc.put(rangeKeyName, Base64.encodeToString(toArray(rangeKey.getB())));
        } else {
            throw new UnsupportedOperationException("DirectKmsMaterialProvider only supports String, Number, and Binary RangeKeys");
        }
    }

    final String tableName = context.getTableName();
    if (tableName != null) {
        kmsEc.put(TABLE_NAME_EC_KEY, tableName);
    }
}
 

/**
 * @see #marshallDescription(Map)
 */
protected static Map<String, String> unmarshallDescription(AttributeValue attributeValue) {
    attributeValue.getB().mark();
    try (DataInputStream in = new DataInputStream(
                new ByteBufferInputStream(attributeValue.getB())) ) {
        Map<String, String> result = new HashMap<String, String>();
        int version = in.readInt();
        if (version != CURRENT_VERSION) {
            throw new IllegalArgumentException("Unsupported description version");
        }

        String key, value;
        int keyLength, valueLength;
        try {
            while(in.available() > 0) {
                keyLength = in.readInt();
                byte[] bytes = new byte[keyLength];
                if (in.read(bytes) != keyLength) {
                    throw new IllegalArgumentException("Malformed description");
                }
                key = new String(bytes, UTF8);
                valueLength = in.readInt();
                bytes = new byte[valueLength];
                if (in.read(bytes) != valueLength) {
                    throw new IllegalArgumentException("Malformed description");
                }
                value = new String(bytes, UTF8);
                result.put(key, value);
            }
        } catch (EOFException eof) {
            throw new IllegalArgumentException("Malformed description", eof);
        }
        return result;
    } catch (IOException ex) {
        // Due to the objects in use, an IOException is not possible.
        throw new RuntimeException("Unexpected exception", ex);
    } finally {
        attributeValue.getB().reset();
    }
}
 

public static BUnmarshaller getByteBufferBUnmarshaller() {
    return new BUnmarshaller() {

        @Override
        public Object unmarshall(final AttributeValue value) throws ParseException {
            return value.getB();
        }
    };
}
 

@Override
protected JsonElement to(AttributeValue value) {
    //the output JASON care only for one type of attribute.
    JsonElement el = new JsonString("");
    try {
        if(value.getS()!=null) {
            el = JsonElement.wrap(value.getS());
        } else if(value.getN()!=null) {
            el = JsonElement.wrap(value.getN());
        }
        else if(value.getSS()!=null) {
            el = JsonElement.wrap(value.getSS());
        }
        else if(value.getNS()!=null) {
            el = JsonElement.wrap(value.getNS());
        }
        else if(value.getB()!=null) {
            el = JsonElement.wrap(value.getB());
        }
        else if(value.getN()!=null) {
            el = JsonElement.wrap(value.getBS());
        }

    } catch (JsonException e) {
        e.printStackTrace();
    }
    return el;
}
 

private List<DColumn> loadAttributes(Map<String, AttributeValue> attributeMap,
                                     Predicate<String> colNamePredicate) {
    List<DColumn> columns = new ArrayList<>();
    if (attributeMap != null) {
        for (Map.Entry<String, AttributeValue> mapEntry : attributeMap.entrySet()) {
            String colName = mapEntry.getKey();
            if (!colName.equals(DynamoDBService.ROW_KEY_ATTR_NAME) && // Don't add row key attribute as a column
                            colNamePredicate.test(colName)) {
                AttributeValue attrValue = mapEntry.getValue();
                if (attrValue.getB() != null) {
                    columns.add(new DColumn(colName, Utils.getBytes(attrValue.getB())));
                } else if (attrValue.getS() != null) {
                    String value = attrValue.getS();
                    if (value.equals(DynamoDBService.NULL_COLUMN_MARKER)) {
                        value = "";
                    }
                    columns.add(new DColumn(colName, value));
                } else {
                    throw new RuntimeException("Unknown AttributeValue type: " + attrValue);
                }
            }
        }
    }
    
    // Sort or reverse sort column names.
    Collections.sort(columns, new Comparator<DColumn>() {
        @Override public int compare(DColumn col1, DColumn col2) {
            return col1.getName().compareTo(col2.getName());
        }
    });
    return columns;
}
 

private static boolean expectedValueMatches(AttributeValue expected, AttributeValue actual) {
    if (expected.getN() != null) {
        return actual.getN() != null && new BigDecimal(expected.getN()).compareTo(new BigDecimal(actual.getN())) == 0;
    } else if (expected.getS() != null || expected.getB() != null) {
        return expected.equals(actual);
    } else {
        throw new IllegalArgumentException("Expect condition using unsupported value type: " + expected);
    }
}
 

@Override
public Object getHiveData(AttributeValue data, ObjectInspector objectInspector) {
  return data.getB() == null ? null : data.getB().array();
}
 

/**
 * Helper method that can clone an Attribute Value
 *
 * @param val the AttributeValue to copy
 * @param sourceDestinationMap used to avoid loops by keeping track of references
 * @return a copy of val
 */
public static AttributeValue clone(final AttributeValue val, final IdentityHashMap<AttributeValue, AttributeValue> sourceDestinationMap) {
    if (val == null) {
        return null;
    }

    if (sourceDestinationMap.containsKey(val)) {
        return sourceDestinationMap.get(val);
    }

    final AttributeValue clonedVal = new AttributeValue();
    sourceDestinationMap.put(val, clonedVal);
    if (val.getN() != null) {
        clonedVal.setN(val.getN());
    } else if (val.getS() != null) {
        clonedVal.setS(val.getS());
    } else if (val.getB() != null) {
        clonedVal.setB(val.getB());
    } else if (val.getNS() != null) {
        clonedVal.setNS(val.getNS());
    } else if (val.getSS() != null) {
        clonedVal.setSS(val.getSS());
    } else if (val.getBS() != null) {
        clonedVal.setBS(val.getBS());
    } else if (val.getBOOL() != null) {
        clonedVal.setBOOL(val.getBOOL());
    } else if (val.getNULL() != null) {
        clonedVal.setNULL(val.getNULL());
    } else if (val.getL() != null) {
        final List<AttributeValue> list = new ArrayList<>(val.getL().size());
        for (AttributeValue listItemValue : val.getL()) {
            if (!sourceDestinationMap.containsKey(listItemValue)) {
                sourceDestinationMap.put(listItemValue, clone(listItemValue, sourceDestinationMap));
            }
            list.add(sourceDestinationMap.get(listItemValue));
        }
        clonedVal.setL(list);
    } else if (val.getM() != null) {
        final Map<String, AttributeValue> map = new HashMap<>(val.getM().size());
        for (Entry<String, AttributeValue> pair : val.getM().entrySet()) {
            if (!sourceDestinationMap.containsKey(pair.getValue())) {
                sourceDestinationMap.put(pair.getValue(), clone(pair.getValue(), sourceDestinationMap));
            }
            map.put(pair.getKey(), sourceDestinationMap.get(pair.getValue()));
        }
        clonedVal.setM(map);
    }
    return clonedVal;
}
 

private static void marshall(final AttributeValue attributeValue, final DataOutputStream out)
        throws IOException {
    
    if (attributeValue.getB() != null) {
        out.writeChar('b');
        writeBytes(attributeValue.getB(), out);
    } else if (attributeValue.getBS() != null) {
        out.writeChar('B');
        writeBytesList(attributeValue.getBS(), out);
    } else if (attributeValue.getN() != null) {
        out.writeChar('n');
        writeString(trimZeros(attributeValue.getN()), out);
    } else if (attributeValue.getNS() != null) {
        out.writeChar('N');

        final List<String> ns = new ArrayList<String>(attributeValue.getNS().size());
        for (final String n : attributeValue.getNS()) {
            ns.add(trimZeros(n));
        }
        writeStringList(ns, out);
    } else if (attributeValue.getS() != null) {
        out.writeChar('s');
        writeString(attributeValue.getS(), out);
    } else if (attributeValue.getSS() != null) {
        out.writeChar('S');
        writeStringList(attributeValue.getSS(), out);
    } else if (attributeValue.getBOOL() != null) {
        out.writeChar('?');
        out.writeByte((attributeValue.getBOOL() ? TRUE_FLAG : FALSE_FLAG));
    } else if (Boolean.TRUE.equals(attributeValue.getNULL())) {
        out.writeChar('\0');
    } else if (attributeValue.getL() != null) {
        final List<AttributeValue> l = attributeValue.getL();
        out.writeChar('L');
        out.writeInt(l.size());
        for (final AttributeValue attr : l) {
            if (attr == null) {
                throw new NullPointerException(
                    "Encountered null list entry value while marshalling attribute value "
                    + attributeValue);
            }
            marshall(attr, out);
        }
    } else if (attributeValue.getM() != null) {
        final Map<String, AttributeValue> m = attributeValue.getM();
        final List<String> mKeys = new ArrayList<String>(m.keySet());
        Collections.sort(mKeys);
        out.writeChar('M');
        out.writeInt(m.size());
        for (final String mKey : mKeys) {
            marshall(new AttributeValue().withS(mKey), out);
            
            final AttributeValue mValue = m.get(mKey);
            
            if (mValue == null) {
                throw new NullPointerException(
                    "Encountered null map value for key "
                    + mKey
                    + " while marshalling attribute value "
                    + attributeValue);
            }
            marshall(mValue, out);
        }
    } else {
        throw new IllegalArgumentException("A seemingly empty AttributeValue is indicative of invalid input or potential errors");
    }
}