Java ColumnType类代码示例

import org.apache.metamodel.schema.ColumnType; //导入依赖的package包/类
private void addColumn(Column rawColumn, MTable mTable) {
    String columnName = rawColumn.getName();
    ColumnType columnType = rawColumn.getType();
    if (ColumnType.STRING.getName().equalsIgnoreCase(columnType.getName())) {
        columnType = ColumnTypeImpl.convertColumnType(Types.VARCHAR);
    }
    int jdbcType = columnType.getJdbcType();
    int typeInfo = -1;
    if (jdbcType == Types.VARCHAR) {
        Integer columnSize = rawColumn.getColumnSize();
        if (columnSize == null) {
            // FIXME: what is the proper length value?
            typeInfo = 128;
        } else {
            typeInfo = columnSize;
        }
    }

    LOG.debug("add column. columnName=" + columnName + ", jdbcType=" + jdbcType + ", typeInfo=" + typeInfo);
    MColumn mColumn = new MColumn(columnName, jdbcType, typeInfo, mTable);
    pm.makePersistent(mColumn);
}
 

import org.apache.metamodel.schema.ColumnType; //导入依赖的package包/类
public SimpleTableDefPanel(final SimpleTableDef tableDef) {
    _tableName = tableDef.getName();
    final String[] names = tableDef.getColumnNames();
    final ColumnType[] types = tableDef.getColumnTypes();

    _tableModel = new DefaultTableModel(new String[] { "Field name", "Type" }, 0);
    for (int i = 0; i < names.length; i++) {
        addField(names[i], types[i]);
    }

    _table = new DCTable(_tableModel);
    _table.setSortable(false);
    _table.setColumnControlVisible(false);
    _table.setRowHeight(DCTable.EDITABLE_TABLE_ROW_HEIGHT);

    setLayout(new BorderLayout());
    add(createButtonPanel(), BorderLayout.NORTH);
    add(_table.toPanel(), BorderLayout.CENTER);
}
 

import org.apache.metamodel.schema.ColumnType; //导入依赖的package包/类
private void addField(String name, ColumnType columnType) {
    if (name == null) {
        name = "";
    }
    final JXTextField nameTextField = WidgetFactory.createTextField();
    nameTextField.setText(name);

    if (columnType == null) {
        columnType = ColumnType.VARCHAR;
    }
    final DCComboBox<ColumnType> typeComboBox = new DCComboBox<>(getAvailableColumnTypes());
    typeComboBox.setRenderer(new EnumComboBoxListRenderer());
    typeComboBox.setSelectedItem(columnType);

    _tableModel.addRow(new Object[] { nameTextField, typeComboBox });
    updateUI();
}
 

import org.apache.metamodel.schema.ColumnType; //导入依赖的package包/类
private AnalysisJobMetadata createMetadata() {
    final String jobName = "job-name";
    final String jobVersion = "job-version";
    final String jobDescription = "job-description";
    final String author = "author";
    final Date createdDate = new Date();
    final Date updatedDate = new Date();
    final String datastoreName = "orderdb";
    final List<String> sourceColumnPaths = new ArrayList<>();
    final List<ColumnType> sourceColumnTypes = new ArrayList<>();
    final Map<String, String> variables = new HashMap<>();
    final Map<String, String> properties = new HashMap<>();

    return new ImmutableAnalysisJobMetadata(jobName, jobVersion, jobDescription, author, createdDate, updatedDate,
            datastoreName, sourceColumnPaths, sourceColumnTypes, variables, properties);
}
 

import org.apache.metamodel.schema.ColumnType; //导入依赖的package包/类
public void testInitializeReordered() throws Exception {
    final DataCleanerConfiguration configuration = new DataCleanerConfigurationImpl();

    try (AnalysisJobBuilder ajb = new AnalysisJobBuilder(configuration)) {
        ajb.addSourceColumn(new MutableColumn("foo", ColumnType.VARCHAR));
        ajb.addSourceColumn(new MutableColumn("bar", ColumnType.VARCHAR));
        ajb.addSourceColumn(new MutableColumn("baz", ColumnType.NVARCHAR));

        final AnalyzerComponentBuilder<StringAnalyzer> beanJobBuilder = ajb.addAnalyzer(StringAnalyzer.class);
        final ConfiguredPropertyDescriptor property =
                beanJobBuilder.getDescriptor().getConfiguredPropertiesForInput().iterator().next();

        // initialize with "baz" + "foo"
        final MultipleInputColumnsPropertyWidget widget =
                new MultipleInputColumnsPropertyWidget(beanJobBuilder, property);
        final InputColumn<?>[] value =
                new InputColumn[] { ajb.getSourceColumnByName("baz"), ajb.getSourceColumnByName("foo") };
        widget.initialize(value);

        assertEquals("baz,foo,bar", getAvailableCheckBoxValues(widget));
        assertEquals("[MetaModelInputColumn[baz], MetaModelInputColumn[foo]]", Arrays.toString(widget.getValue()));
    }
}
 

import org.apache.metamodel.schema.ColumnType; //导入依赖的package包/类
@Override
public OutputDataStream[] getOutputDataStreams() {
    final OutputDataStreamBuilder builder = OutputDataStreams.pushDataStream(OUTPUT_DATA_STREAM_NAME);
    boolean foundOutputDataStream = false;
    for (final CoalesceUnit unit : _units) {
        // Not necessarily initialized yet, so no _initializedUnits available
        final InputColumn<?>[] updatedInputColumns = unit.getUpdatedInputColumns(_inputs, false);
        if (unit.getInputColumnNames().length == updatedInputColumns.length) {
            // Valid Unit
            foundOutputDataStream = true;
            final CoalesceUnit updatedCoalesceUnit = unit.getUpdatedCoalesceUnit(updatedInputColumns);
            final Class<?> dataType = updatedCoalesceUnit.getOutputDataType();
            final String columnName = updatedCoalesceUnit.getSuggestedOutputColumnName();
            final ColumnType columnType = ColumnTypeImpl.convertColumnType(dataType);
            builder.withColumn(columnName, columnType);
        } else {
            logger.info("Missing columns detected, skipping coalesce unit");
        }
    }
    if (!foundOutputDataStream) {
        return new OutputDataStream[0];
    }
    return new OutputDataStream[] { builder.toOutputDataStream() };
}
 

import org.apache.metamodel.schema.ColumnType; //导入依赖的package包/类
@Override
protected void setUp() throws Exception {
    super.setUp();
    if (jdbcDatastore == null) {
        jdbcDatastore = new JdbcDatastore("my datastore", "jdbc:hsqldb:mem:UpdateTable_testErrorHandlingOption",
                "org.hsqldb.jdbcDriver");
        final UpdateableDatastoreConnection con = jdbcDatastore.openConnection();
        final UpdateableDataContext dc = con.getUpdateableDataContext();
        if (dc.getDefaultSchema().getTableByName("test_table") == null) {
            dc.executeUpdate(cb -> {
                final Table table = cb.createTable(dc.getDefaultSchema(), "test_table").withColumn("foo")
                        .ofType(ColumnType.VARCHAR).withColumn("bar").ofType(ColumnType.INTEGER).withColumn("baz")
                        .ofType(ColumnType.VARCHAR).execute();

                cb.insertInto(table).value("foo", "a").value("bar", 1).value("baz", "lorem").execute();
                cb.insertInto(table).value("foo", "b").value("bar", 2).value("baz", "ipsum").execute();
                cb.insertInto(table).value("foo", "c").value("bar", 3).value("baz", "dolor").execute();
                cb.insertInto(table).value("foo", "d").value("bar", 4).value("baz", "sit").execute();
                cb.insertInto(table).value("foo", "e").value("bar", 5).value("baz", "amet").execute();
            });
        }
        con.close();
    }
}
 

import org.apache.metamodel.schema.ColumnType; //导入依赖的package包/类
@Test
public void shouldReturnAStringTypeForLiteralColumn() {
    final Column literalColumn = new MutableColumn("foo", ColumnType.CHAR);

    Object result = TypeConverter.convertType("bla", literalColumn);
    assertTrue(result instanceof String);
    assertEquals("bla", result);

    result = TypeConverter.convertType(24, literalColumn);
    assertTrue(result instanceof String);
    assertEquals("24", result);

    result = TypeConverter.convertType(24.3d, literalColumn);
    assertTrue(result instanceof String);
    assertEquals("24.3", result);

    result = TypeConverter.convertType(dateValue, literalColumn);
    assertTrue(result instanceof String);
    assertEquals(dateValue.toString(), result);

}
 

import org.apache.metamodel.schema.ColumnType; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
    updateableDatastore = new PojoDatastore("my datastore");
    final UpdateableDatastoreConnection con = updateableDatastore.openConnection();
    final UpdateableDataContext dc = con.getUpdateableDataContext();
    if (dc.getDefaultSchema().getTableByName(TEST_TABLE_NAME) == null) {
        dc.executeUpdate(cb -> {
            cb.createTable(dc.getDefaultSchema(), TEST_TABLE_NAME).withColumn(VARCHAR_COLUMN_NAME)
                    .ofType(ColumnType.VARCHAR).withColumn(INTEGER_COLUMN_NAME).ofType(ColumnType.INTEGER)
                    .execute();
            cb.insertInto(TEST_TABLE_NAME).value(VARCHAR_COLUMN_NAME, VARCHAR_COLUMN_VALUE)
                    .value(INTEGER_COLUMN_NAME, INTEGER_COLUMN_VALUE).execute();
        });
    }
    con.close();
}
 

import org.apache.metamodel.schema.ColumnType; //导入依赖的package包/类
public void addColumnToOutputStream(final OutputDataStreamBuilder outputDataStreamBuilder,
        final InputColumn<?> inputColumn) {
    switch (this) {
    case FIRST_VALUE:
    case LAST_VALUE:
    case RANDOM_VALUE:
        outputDataStreamBuilder.withColumnLike(inputColumn);
        break;
    case SUM:
    case AVG:
        outputDataStreamBuilder.withColumn(inputColumn.getName(), ColumnType.NUMBER);
        break;
    case CONCAT_VALUES:
        outputDataStreamBuilder.withColumn(inputColumn.getName(), ColumnType.STRING);
        break;
    case CREATE_LIST:
        outputDataStreamBuilder.withColumn(inputColumn.getName(), ColumnType.LIST);
        break;
    default:
        throw new UnsupportedOperationException("Unsupported aggregation type: " + this);
    }

}
 

import org.apache.metamodel.schema.ColumnType; //导入依赖的package包/类
@Override
public OutputDataStream[] getOutputDataStreams() {
    final OutputDataStreamBuilder outputDataStreamBuilder = OutputDataStreams.pushDataStream("output");
    outputDataStreamBuilder.withColumnLike(groupKey);
    outputDataStreamBuilder.withColumn("row_count", ColumnType.INTEGER);
    for (int i = 0; i < aggregatedValues.length; i++) {
        final InputColumn<?> inputColumn = aggregatedValues[i];
        final AggregationType aggregationType =
                (aggregationTypes.length <= i ? AggregationType.CREATE_LIST : aggregationTypes[i]);

        if (aggregationType != null) {
            aggregationType.addColumnToOutputStream(outputDataStreamBuilder, inputColumn);
        }
    }

    final OutputDataStream stream = outputDataStreamBuilder.toOutputDataStream();
    return new OutputDataStream[] { stream };
}
 

import org.apache.metamodel.schema.ColumnType; //导入依赖的package包/类
private Object convert(String stringValue, ColumnType type) {
    if (stringValue == null || stringValue.length() == 0) {
        return null;
    }

    if (type == ColumnType.FLOAT) {
        return Float.parseFloat(stringValue);
    } else if (type == ColumnType.DOUBLE) {
        return Double.parseDouble(stringValue);
    } else if (type == ColumnType.DATE) {
        try {
            Date date = new SimpleDateFormat("yyyyMMdd").parse(stringValue);
            return date;
        } catch (ParseException e) {
            throw new IllegalArgumentException(stringValue);
        }
    } else {
        return stringValue;
    }
}
 

import org.apache.metamodel.schema.ColumnType; //导入依赖的package包/类
@Override
protected void setUp() throws Exception {
    super.setUp();
    if (jdbcDatastore == null) {
        jdbcDatastore = new JdbcDatastore("my datastore",
                "jdbc:hsqldb:mem:InsertIntoTable_testErrorHandlingOption", "org.hsqldb.jdbcDriver");
        final UpdateableDatastoreConnection con = jdbcDatastore.openConnection();
        final UpdateableDataContext dc = con.getUpdateableDataContext();
        if (dc.getDefaultSchema().getTableByName("test_table") == null) {
            dc.executeUpdate(new UpdateScript() {
                @Override
                public void run(UpdateCallback cb) {
                    cb.createTable(dc.getDefaultSchema(), "test_table").withColumn("foo")
                            .ofType(ColumnType.VARCHAR).withColumn("bar").ofType(ColumnType.INTEGER).execute();
                }
            });
        }
        con.close();
    }
}
 

import org.apache.metamodel.schema.ColumnType; //导入依赖的package包/类
public void testConfigurableBeanConfiguration() throws Exception {
    AnalysisJobBuilder ajb = new AnalysisJobBuilder(new AnalyzerBeansConfigurationImpl());
    try {
        List<TableDataProvider<?>> tableDataProviders = Collections.emptyList();
        ajb.setDatastore(new PojoDatastore("ds", tableDataProviders));
        ajb.addSourceColumn(new MutableColumn("foo", ColumnType.VARCHAR));
        
        AnalyzerJobBuilder<CompletenessAnalyzer> analyzer = ajb.addAnalyzer(CompletenessAnalyzer.class);
        analyzer.getConfigurableBean().setValueColumns(ajb.getSourceColumns().toArray(new InputColumn[0]));
        analyzer.getConfigurableBean().fillAllConditions(Condition.NOT_BLANK_OR_NULL);
        
        assertTrue(analyzer.isConfigured(true));
    } finally {
        ajb.close();
    }
}
 

import org.apache.metamodel.schema.ColumnType; //导入依赖的package包/类
private ColumnType getColumnType(ValueMetaInterface valueMeta) {
    switch (valueMeta.getType()) {
    case ValueMetaInterface.TYPE_STRING:
        return ColumnType.VARCHAR;
    case ValueMetaInterface.TYPE_INTEGER:
        return ColumnType.INTEGER;
    case ValueMetaInterface.TYPE_DATE:
        return ColumnType.DATE;
    case ValueMetaInterface.TYPE_BOOLEAN:
        return ColumnType.BOOLEAN;
    case ValueMetaInterface.TYPE_NUMBER:
        return ColumnType.DOUBLE;
    case ValueMetaInterface.TYPE_BINARY:
        return ColumnType.BINARY;
    case ValueMetaInterface.TYPE_BIGNUMBER:
        return ColumnType.DECIMAL;
    }
    throw new RuntimeException("It is currently not possible to profile values of type: " + valueMeta.getTypeDesc());
}