/** * Create a primitive fi * @param typeName * @return */ public static SqlFieldSchema createPrimitiveSchema(SamzaSqlFieldType typeName) { return new SqlFieldSchema(typeName, null, null, null); }
public String getReturnType() { return returnType.getFieldType().toString(); }
public static SqlSchemaBuilder builder() { return new SqlSchemaBuilder(); }
@Test public void testGetTableSchema() { ExecutionContext context = getExecutionContext(); SqlSchema ts = m_executor.getTableSchema(context, "kafka.ProfileChangeStream"); List<SqlSchema.SqlField> fields = ts.getFields(); Assert.assertEquals("Name", fields.get(0).getFieldName()); Assert.assertEquals("NewCompany", fields.get(1).getFieldName()); Assert.assertEquals("OldCompany", fields.get(2).getFieldName()); Assert.assertEquals("ProfileChangeTimestamp", fields.get(3).getFieldName()); Assert.assertEquals("STRING", fields.get(0).getFieldSchema().getFieldType().toString()); Assert.assertEquals("STRING", fields.get(1).getFieldSchema().getFieldType().toString()); Assert.assertEquals("STRING", fields.get(2).getFieldSchema().getFieldType().toString()); Assert.assertEquals("INT64", fields.get(3).getFieldSchema().getFieldType().toString()); }
private List<RelDataTypeField> getRelFields(List<SqlSchema.SqlField> fields) { List<RelDataTypeField> relFields = new ArrayList<>(); for (SqlSchema.SqlField field : fields) { String fieldName = field.getFieldName(); int fieldPos = field.getPosition() + 1; RelDataType dataType = getRelDataType(field.getFieldSchema()); relFields.add(new RelDataTypeFieldImpl(fieldName, fieldPos, dataType)); } return relFields; }
case ARRAY: SqlFieldSchema elementSchema = convertField(fieldSchema.getElementType()); return SqlFieldSchema.createArraySchema(elementSchema); case BOOLEAN: return SqlFieldSchema.createPrimitiveSchema(SamzaSqlFieldType.BOOLEAN); case DOUBLE: return SqlFieldSchema.createPrimitiveSchema(SamzaSqlFieldType.DOUBLE); case FLOAT: return SqlFieldSchema.createPrimitiveSchema(SamzaSqlFieldType.FLOAT); case ENUM: return SqlFieldSchema.createPrimitiveSchema(SamzaSqlFieldType.STRING); case UNION: return getSqlTypeFromUnionTypes(fieldSchema.getTypes()); case FIXED: return SqlFieldSchema.createPrimitiveSchema(SamzaSqlFieldType.BYTES); case STRING: return SqlFieldSchema.createPrimitiveSchema(SamzaSqlFieldType.STRING); case BYTES: return SqlFieldSchema.createPrimitiveSchema(SamzaSqlFieldType.BYTES); case INT: return SqlFieldSchema.createPrimitiveSchema(SamzaSqlFieldType.INT32); case LONG: return SqlFieldSchema.createPrimitiveSchema(SamzaSqlFieldType.INT64); case RECORD: SqlSchema rowSchema = convertSchema(fieldSchema.getFields()); return SqlFieldSchema.createRowFieldSchema(rowSchema); case MAP: SqlFieldSchema valueType = convertField(fieldSchema.getValueType()); return SqlFieldSchema.createMapSchema(valueType);
private SqlSchema convertSchema(List<Schema.Field> fields) { Validate.notEmpty(fields, "Fields cannot be empty"); SqlSchemaBuilder schemaBuilder = SqlSchemaBuilder.builder(); for (Schema.Field field : fields) { SqlFieldSchema fieldSchema = convertField(field.schema()); schemaBuilder.addField(field.name(), fieldSchema); } return schemaBuilder.build(); }
private RelDataType convertRecordType(SqlSchema schema) { List<RelDataTypeField> relFields = getRelFields(schema.getFields()); return new RelRecordType(relFields); }
public SqlSchema build() { return new SqlSchema(fieldNames, fieldSchemas); } }
@Override public List<SqlFunction> listFunctions(ExecutionContext context) { /** * TODO: currently the Shell only shows some UDFs supported by Samza internally. We may need to require UDFs * to provide a function of getting their "SamzaSqlUdfDisplayInfo", then we can get the UDF information from * SamzaSqlApplicationConfig.udfResolver(or SamzaSqlApplicationConfig.udfMetadata) instead of registering * UDFs one by one as below. */ List<SqlFunction> udfs = new ArrayList<>(); udfs.add(new SamzaSqlUdfDisplayInfo("RegexMatch", "Matches the string to the regex", Arrays.asList(SqlFieldSchema.createPrimitiveSchema(SamzaSqlFieldType.STRING), SqlFieldSchema.createPrimitiveSchema(SamzaSqlFieldType.STRING)), SqlFieldSchema.createPrimitiveSchema(SamzaSqlFieldType.BOOLEAN))); return udfs; }
public SqlSchema(List<String> colNames, List<SqlFieldSchema> colTypes) { if (colNames == null || colNames.size() == 0 || colTypes == null || colTypes.size() == 0 || colNames.size() != colTypes.size()) { throw new IllegalArgumentException(); } fields = IntStream.range(0, colTypes.size()) .mapToObj(i -> new SqlField(i, colNames.get(i), colTypes.get(i))) .collect(Collectors.toList()); }
@Ignore @Test public void testGenerateResultSchema() { ExecutionContext context = getExecutionContext(); Map<String, String> mapConf = fetchSamzaSqlConfig(1, context); SqlSchema ts = m_executor.generateResultSchema(new MapConfig(mapConf)); List<SqlSchema.SqlField> fields = ts.getFields(); Assert.assertEquals("__key__", fields.get(0).getFieldName()); Assert.assertEquals("Name", fields.get(1).getFieldName()); Assert.assertEquals("NewCompany", fields.get(2).getFieldName()); Assert.assertEquals("OldCompany", fields.get(3).getFieldName()); Assert.assertEquals("ProfileChangeTimestamp", fields.get(4).getFieldName()); Assert.assertEquals("ANY", fields.get(0).getFieldSchema().getFieldType().toString()); Assert.assertEquals("VARCHAR", fields.get(1).getFieldSchema().getFieldType().toString()); Assert.assertEquals("VARCHAR", fields.get(2).getFieldSchema().getFieldType().toString()); Assert.assertEquals("VARCHAR", fields.get(3).getFieldSchema().getFieldType().toString()); Assert.assertEquals("BIGINT", fields.get(4).getFieldSchema().getFieldType().toString()); }
public List<String> getArgumentTypes() { return argumentTypes.stream().map(x -> x.getFieldType().toString()).collect(Collectors.toList()); }
SqlSchema generateResultSchema(Config config) { SamzaSqlDslConverter converter = (SamzaSqlDslConverter) new SamzaSqlDslConverterFactory().create(config); RelRoot relRoot = converter.convertDsl("").iterator().next(); List<String> colNames = new ArrayList<>(); List<String> colTypeNames = new ArrayList<>(); for (RelDataTypeField dataTypeField : relRoot.validatedRowType.getFieldList()) { colNames.add(dataTypeField.getName()); colTypeNames.add(dataTypeField.getType().toString()); } // TODO Need to find a way to convert the relational to SQL Schema return new SqlSchema(colNames, Collections.emptyList()); }
private SqlFieldSchema getSqlTypeFromUnionTypes(List<Schema> types) { // Typically a nullable field's schema is configured as an union of Null and a Type. // This is to check whether the Union is a Nullable field if (types.size() == 2) { if (types.get(0).getType() == Schema.Type.NULL) { return convertField(types.get(1)); } else if ((types.get(1).getType() == Schema.Type.NULL)) { return convertField(types.get(0)); } } return SqlFieldSchema.createPrimitiveSchema(SamzaSqlFieldType.ANY); } }
public static SqlFieldSchema createMapSchema(SqlFieldSchema valueType) { return new SqlFieldSchema(SamzaSqlFieldType.MAP, null, valueType, null); }
int minRowNeeded = Integer.MAX_VALUE; int longestLineCharNum = 0; int rowCount = schema.getFields().size(); for (int j = seperatorPos; j < terminalWidth - HEADER_TYPE.length() - 2; ++j) { boolean fieldWrapped = false; int rowNeeded = 0; for (int i = 0; i < rowCount; ++i) { SqlSchema.SqlField field = schema.getFields().get(i); int fieldLen = field.getFieldName().length(); int typeLen = field.getFieldSchema().getFieldType().toString().length(); int fieldRowNeeded = CliUtil.ceilingDiv(fieldLen, j - 2); int typeRowNeeded = CliUtil.ceilingDiv(typeLen, terminalWidth - 1 - j - 2); final int typeColSize = terminalWidth - seperatorPos - 1 - 2; for (int i = 0; i < rowCount; ++i) { SqlSchema.SqlField sqlField = schema.getFields().get(i); String field = sqlField.getFieldName(); String type = sqlField.getFieldSchema().getFieldType().toString(); int fieldLen = field.length(); int typeLen = type.length();
public String toString() { List<String> argumentTypeNames = argumentTypes.stream().map(x -> x.getFieldType().toString()).collect(Collectors.toList()); String args = Joiner.on(", ").join(argumentTypeNames); return String.format("%s(%s) returns <%s> : %s", name, args, returnType.getFieldType().toString(), description); } }
public static SqlFieldSchema createArraySchema(SqlFieldSchema elementType) { return new SqlFieldSchema(SamzaSqlFieldType.ARRAY, elementType, null, null); }
public static SqlFieldSchema createRowFieldSchema(SqlSchema rowSchema) { return new SqlFieldSchema(SamzaSqlFieldType.ROW, null, null, rowSchema); }