public String getPrettyName() { if (isArray()) { return "ARRAY<" + getArrayElementType().toString() + ">"; } if (isMap()) { return "MAP<STRING, " + getMapValueType().toString() + ">"; } return toString(); } }
private Map<String, Object> getMap(FieldType mapValueType, String valueAsString) throws IOException { Map<String, Object> map = new HashMap<>(); JsonParser parser = jsonFactory.createParser(valueAsString); JsonToken t = parser.getCurrentToken(); if (t != JsonToken.START_OBJECT) { return null; } else { t = parser.nextToken(); } for (; t == JsonToken.FIELD_NAME; t = parser.nextToken()) { String key = parser.getCurrentName(); if (!parser.nextToken().isScalarValue()) { throw new JsonMappingException(String.format("Nested properties are not supported. ('%s' field)", mapValueType.name())); } map.put(key, getValue(mapValueType, parser)); } return map; } }
return TIMESTAMP; case StandardTypes.ARRAY: return fromPrestoType(parameter.next(), null).convertToArrayType(); case StandardTypes.MAP: Preconditions.checkArgument(parameter.next().equals(StandardTypes.VARCHAR), "The first parameter of MAP must be STRING"); return fromPrestoType(parameter.next(), null).convertToMapValueType(); default: return BINARY;
private String sqlArrayTypeName(FieldType fieldType) { if (fieldType.isArray()) { throw new UnsupportedOperationException(); return "date"; default: if (fieldType.isArray()) { return fieldType.getArrayElementType() + "[]"; if (fieldType.isMap()) { return "jsonb";
.filter(field -> field.getType() != BINARY) .map(field -> { if (field.getType().isNumeric()) { return format("\"%1$s\": '|| COALESCE(cast(%1$s as varchar), 'null')||'", field.getName()); if (field.getType().isArray() || field.getType().isMap()) { return format("\"%1$s\": '|| json_format(try_cast(%1$s as json)) ||'", field.getName()); "\"" + prestoConfig.getColdStorageConnector() + "\"" + ".\"" + context.project + "\"." + checkCollection(entry.getKey()), checkTableColumn(projectConfig.getUserColumn()), userType.get().isNumeric() ? user : "'" + user + "'", beforeThisTime == null ? "" : format("and %s < from_iso8601_timestamp('%s')", checkTableColumn(projectConfig.getTimeColumn()), beforeThisTime.toString()))) .collect(Collectors.joining(" union all "));
if (type.isArray() || type.isMap()) { return ARRAY_STRING; return type.convertToArrayType(); case START_OBJECT: t = jp.nextToken(); if (type.isArray() || type.isMap()) { return MAP_STRING; return type.convertToMapValueType(); default: throw new JsonMappingException(jp, format("The type is not supported: %s", jp.getValueAsString()));
private void write(FieldType type, JsonGenerator generator, Object value) throws IOException { switch (type) { case STRING: case BOOLEAN: case LONG: case INTEGER: case DECIMAL: case DOUBLE: case TIMESTAMP: case TIME: case DATE: generator.writeString(value.toString()); break; default: if (type.isMap()) { generator.writeNull(); } else if (type.isArray()) { generator.writeStartArray(); for (Object item : ((List) value)) { generator.writeString(item.toString()); } generator.writeEndArray(); } else { throw new IllegalStateException(format("type %s is not supported.", type)); } } }
public static JDBCType jdbcType(FieldType type) { if (type.equals(FieldType.BOOLEAN)) { return JDBCType.BOOLEAN; } if (type.equals(LONG) || type.equals(TIMESTAMP)) { return JDBCType.BIGINT; } if (type.equals(FieldType.INTEGER)) { return JDBCType.INTEGER; } if (type.equals(FieldType.DOUBLE)) { return JDBCType.DOUBLE; } if (type.equals(FieldType.DATE)) { return JDBCType.INTEGER; } if (type.equals(FieldType.STRING)) { return VARBINARY; } return null; }
@Test public void testCollectionFieldsOrdering() throws Exception { getMetastore().createProject(PROJECT_NAME); ImmutableSet.Builder<SchemaField> builder = ImmutableSet.builder(); for (FieldType fieldType : FieldType.values()) { builder.add(new SchemaField(fieldType.name(), fieldType)); } getMetastore().getOrCreateCollectionFields(PROJECT_NAME, "testcollection", builder.build()); for (int i = 0; i < 100; i++) { assertTrue(getMetastore().getCollection(PROJECT_NAME, "testcollection").containsAll(builder.build())); } }
Optional<SchemaField> existing = fields.stream().filter(e -> e.getName().equals(newField.getName())).findAny(); if (existing.isPresent()) { if (!existing.get().getType().equals(newField.getType())) { throw new IllegalStateException(String.format("Multiple entries with same key for collection %s field %s: %s,%s", collection, newField.getName(), newField.getType(), existing.get().getType())); .put("id", new AttributeValue(rangeKey)) .put("collection", new AttributeValue(collection)).put("name", new AttributeValue(newField.getName())) .put("type", new AttributeValue(newField.getType().name())).build()) ); fields.add(newField); .put("id", new AttributeValue(rangeKey)) .put("collection", new AttributeValue(collection)).put("name", new AttributeValue(newField.getName())) .put("type", new AttributeValue(newField.getType().name())).build()) ); } catch (ConditionalCheckFailedException e1) {
public void incrementProperty(Connection conn, String project, Object userId, String property, double value) throws SQLException { Map<String, FieldType> columns = createMissingColumns(project, userId, ImmutableList.of(new SimpleImmutableEntry<>(property, new DoubleNode(value))), new CommitConnection(conn)); FieldType fieldType = columns.get(property); if (fieldType == null) { createColumn(project, userId, property, JsonHelper.numberNode(0)); } if (!fieldType.isNumeric()) { throw new RakamException(String.format("The property the is %s and it can't be incremented.", fieldType.name()), BAD_REQUEST); } String tableRef = checkTableColumn(stripName(property, "table column")); Statement statement = conn.createStatement(); ProjectCollection userTable = getUserTable(project, false); String table = checkProject(userTable.project, '"') + "." + checkCollection(userTable.collection); int execute = statement.executeUpdate("update " + table + " set " + tableRef + " = " + value + " + coalesce(" + tableRef + ", 0)"); if (execute == 0) { create(project, userId, JsonHelper.jsonObject().put(property, value)); } }
@Subscribe public void onCreateProject(SystemEvents.ProjectCreatedEvent event) { FieldType type = configManager.getConfig(event.project, USER_TYPE.name(), FieldType.class); if (type != null) { if (storage.isPresent()) { storage.get().createProjectIfNotExists(event.project, type.isNumeric()); } } } }
private URI buildInsertUri(ProjectCollection collection, List<SchemaField> schema) { return UriBuilder .fromUri(config.getAddress()) .queryParam("query", format("INSERT INTO %s.%s (`$date`, %s) FORMAT RowBinary", collection.project, checkCollection(collection.collection, '`'), schema.stream().flatMap(f -> f.getType().isMap() ? Stream.of(checkCollection(f.getName(), '`') + ".Key", checkCollection(f.getName(), '`') + ".Value") : Stream.of(checkCollection(f.getName(), '`'))) .collect(Collectors.joining(", ")))).build(); }
return FieldType.STRING; case "Array": return parseClickhouseType(group).convertToArrayType(); case "Nested": return FieldType.MAP_STRING;
break; default: if (type.isArray()) { String typeName = toPostgresqlPrimitiveTypeName(type.getArrayElementType()); ps.setArray(i + 1, connection.createArrayOf(typeName, ((List) value).toArray())); } else if (type.isMap()) { PGobject jsonObject = new PGobject(); jsonObject.setType("jsonb");
if (type.isArray() || type.isMap()) { throw new RakamException("_user field must be numeric or string.", BAD_REQUEST); final FieldType eventUserType = type.isNumeric() ? (type != INTEGER ? LONG : INTEGER) : STRING; type = configManager.setConfigOnce(project, USER_TYPE.name(), eventUserType); if (type.isArray() || type.isMap()) {