import org.embulk.spi.type.TimestampType; //导入依赖的package包/类
private void configure(PluginTask task, Schema inputSchema)
{
    List<ColumnConfig> columns = task.getColumns();

    if (columns.size() < 2) {
        throw new ConfigException("\"columns\" should be specified 2~ columns.");
    }

    // throw if column type is not supported
    for (ColumnConfig columnConfig : columns) {
        String name = columnConfig.getName();
        Type type = inputSchema.lookupColumn(name).getType();

        if (type instanceof JsonType) {
            throw new ConfigException(String.format("casting to json is not available: \"%s\"", name));
        }
        if (type instanceof TimestampType) {
            throw new ConfigException(String.format("casting to timestamp is not available: \"%s\"", name));
        }
    }
}
 

import org.embulk.spi.type.TimestampType; //导入依赖的package包/类
public void setFromBoolean(Column outputColumn, boolean value)
{
    Type outputType = outputColumn.getType();
    if (outputType instanceof BooleanType) {
        pageBuilder.setBoolean(outputColumn, BooleanCast.asBoolean(value));
    }
    else if (outputType instanceof LongType) {
        pageBuilder.setLong(outputColumn, BooleanCast.asLong(value));
    }
    else if (outputType instanceof DoubleType) {
        pageBuilder.setDouble(outputColumn, BooleanCast.asDouble(value));
    }
    else if (outputType instanceof StringType) {
        pageBuilder.setString(outputColumn, BooleanCast.asString(value));
    }
    else if (outputType instanceof TimestampType) {
        pageBuilder.setTimestamp(outputColumn, BooleanCast.asTimestamp(value));
    }
    else if (outputType instanceof JsonType) {
        pageBuilder.setJson(outputColumn, BooleanCast.asJson(value));
    }
    else {
        assert (false);
    }
}
 

import org.embulk.spi.type.TimestampType; //导入依赖的package包/类
private void buildTimestampParserMap()
{
    // columnName => TimestampParser
    for (ColumnConfig columnConfig : task.getColumns()) {
        if (PathCompiler.isProbablyJsonPath(columnConfig.getName())) {
            continue; // type: json columns do not support type: timestamp
        }
        Column inputColumn = inputSchema.lookupColumn(columnConfig.getName());
        if (inputColumn.getType() instanceof StringType && columnConfig.getType() instanceof TimestampType) {
            TimestampParser parser = createTimestampParser(task, columnConfig);
            this.timestampParserMap.put(columnConfig.getName(), parser);
        }
    }
}
 

import org.embulk.spi.type.TimestampType; //导入依赖的package包/类
private void buildTimestampFormatterMap()
{
    // columnName => TimestampFormatter
    for (ColumnConfig columnConfig : task.getColumns()) {
        if (PathCompiler.isProbablyJsonPath(columnConfig.getName())) {
            continue; // type: json columns do not have type: timestamp
        }
        Column inputColumn = inputSchema.lookupColumn(columnConfig.getName());
        if (inputColumn.getType() instanceof TimestampType && columnConfig.getType() instanceof StringType) {
            TimestampFormatter parser = createTimestampFormatter(task, columnConfig);
            this.timestampFormatterMap.put(columnConfig.getName(), parser);
        }
    }
}
 

import org.embulk.spi.type.TimestampType; //导入依赖的package包/类
static Value getDefault(PluginTask task, String name, Type type, ColumnConfig columnConfig)
{
    Object defaultValue = ColumnVisitorImpl.getDefault(task, name, type, columnConfig);
    if (defaultValue == null) {
        return ValueFactory.newNil();
    }
    if (type instanceof BooleanType) {
        return ValueFactory.newBoolean((Boolean) defaultValue);
    }
    else if (type instanceof LongType) {
        return ValueFactory.newInteger((Long) defaultValue);
    }
    else if (type instanceof DoubleType) {
        return ValueFactory.newFloat((Double) defaultValue);
    }
    else if (type instanceof StringType) {
        return ValueFactory.newString((String) defaultValue.toString());
    }
    else if (type instanceof JsonType) {
        return (Value) defaultValue;
    }
    else if (type instanceof TimestampType) {
        throw new ConfigException("type: timestamp is not available in json path");
    }
    else {
        throw new ConfigException(String.format("type: '%s' is not supported", type));
    }
}
 

import org.embulk.spi.type.TimestampType; //导入依赖的package包/类
public static List<DateParser> create(GrokParserPlugin.PluginTask task) {
    switch (task.getTimestampParser().toLowerCase()) {
        case "ruby":
            TimestampParser[] ps = Timestamps.newTimestampColumnParsers(task, task.getColumns());
            return Arrays.stream(ps)
                    .map(parser -> (DateParser) (text) -> parser.parse(text))
                    .collect(Collectors.toList());
        case "epoch":
            return task.getColumns().getColumns().stream()
                    .map(x -> (DateParser) (text) -> Timestamp.ofEpochMilli(Long.parseLong(text)))
                    .collect(Collectors.toList());
        case "sdf":
        case "simpledateformat":
        default:
            SimpleDateFormat[] parsers = new SimpleDateFormat[task.getColumns().getColumnCount()];
            int i = 0;
            for (ColumnConfig column : task.getColumns().getColumns()) {
                if (column.getType() instanceof TimestampType) {
                    TimestampColumnOption option = column.getOption().loadConfig(TimestampColumnOption.class);
                    String format = convertToJavaDateFormat(option.getFormat().or("yyyy-MM-dd HH:MM:ss.SSS z"));
                    SimpleDateFormat sdf = new SimpleDateFormat(format, Locale.ENGLISH);
                    sdf.setTimeZone(option.getTimeZone().or(DateTimeZone.UTC).toTimeZone());
                    parsers[i] = sdf;
                }
                i++;
            }
            return Arrays.stream(parsers).map(parser ->
                    (DateParser) (String date) -> {
                        try {
                            return Timestamp.ofEpochMilli(parser.parse(date).getTime());
                        } catch (ParseException e) {
                            throw new GrokRecordValidateException(e);
                        }
                    }).collect(Collectors.toList());
    }
}
 

import org.embulk.spi.type.TimestampType; //导入依赖的package包/类
public boolean isTimestamp()
{
    return (column.getType() instanceof TimestampType);
}