private BatchManagerImpl(Long newID, Class<?>[] types) { this.id = newID; this.sizeUtility = new SizeUtility(types); this.types = new String[types.length]; for (int i = 0; i < types.length; i++) { this.types[i] = DataTypeManager.getDataTypeName(types[i]); } }
public static boolean isImplicitConversion(String srcType, String tgtType) { Transform t = getTransform(srcType, tgtType); if (t != null) { return !t.isExplicit(); } if (DefaultDataTypes.NULL.equals(srcType) && !DefaultDataTypes.NULL.equals(tgtType)) { return true; } if (DefaultDataTypes.OBJECT.equals(tgtType) && !DefaultDataTypes.OBJECT.equals(srcType)) { return true; } if (isArrayType(srcType) && isArrayType(tgtType)) { return isImplicitConversion(getComponentType(srcType), getComponentType(tgtType)); } return false; }
private void addAliasType(String alias) { Class<?> typeClass = DataTypeManager.getDataTypeClass(alias); String primaryType = DataTypeManager.getDataTypeName(typeClass); Datatype dt = typeMap.get(primaryType); Assertion.isNotNull(dt, alias); typeMap.put(alias, dt); }
public static EdmType odataType(String teiidType) { if (DataTypeManager.isArrayType(teiidType)) { return new EdmCollectionType(CollectionKind.Collection, odataType(DataTypeManager.getComponentType(teiidType))); } return teiidkeyed.get(teiidType); }
@Override public Class<?> getDataTypeClass(String typeOrDomainName) throws QueryMetadataException { if (typeOrDomainName == null) { return DefaultDataClasses.NULL; } Datatype type = store.getDatatypes().get(typeOrDomainName); if (type != null) { return DataTypeManager.getDataTypeClass(type.getRuntimeTypeName()); } if (DataTypeManager.isArrayType(typeOrDomainName)) { return DataTypeManager.getArrayType(getDataTypeClass(typeOrDomainName.substring(0, typeOrDomainName.length() - 2))); } throw new QueryMetadataException(QueryPlugin.Event.TEIID31254, QueryPlugin.Util.gs(QueryPlugin.Event.TEIID31254, typeOrDomainName)); }
public static Object convert(CommandContext context, Object src, String type) throws FunctionExecutionException { try { if (context == null || context.getMetadata() == null) { return DataTypeManager.transformValue(src, DataTypeManager.getDataTypeClass(type)); } return DataTypeManager.transformValue(src, context.getMetadata().getDataTypeClass(type)); } catch(TransformationException e) { throw new FunctionExecutionException(QueryPlugin.Event.TEIID30405, e, QueryPlugin.Util.gs(QueryPlugin.Event.TEIID30405, new Object[]{src, DataTypeManager.getDataTypeName(src.getClass()), type})); } catch (QueryMetadataException e) { throw new FunctionExecutionException(QueryPlugin.Event.TEIID30405, e, QueryPlugin.Util.gs(QueryPlugin.Event.TEIID30405, new Object[]{src, DataTypeManager.getDataTypeName(src.getClass()), type})); } }
Object value) throws TransformationException, SQLException, IOException, FunctionExecutionException { Class<?> sourceType = DataTypeManager.getRuntimeType(value.getClass()); if (sourceType.isAssignableFrom(expectedType.getDefaultType())) { return value; Class<?> targetType = DataTypeManager.getDataTypeClass(ODataTypeManager.teiidType(expectedType, isArray)); if (sourceType != targetType) { Transform t = DataTypeManager.getTransform(sourceType, targetType); value = t != null ? t.transform(value, targetType) : value;
public static Object importValue(Object result, Class<?> expectedType) throws ArithmeticException, TransformationException { if (!ALLOW_NAN_INFINITY) { if (result instanceof Double) { Double floatVal = (Double)result; if (Double.isInfinite(floatVal) || Double.isNaN(floatVal)) { throw new ArithmeticException("Infinite or invalid result"); //$NON-NLS-1$ } } else if (result instanceof Float) { Float floatVal = (Float)result; if (Float.isInfinite(floatVal) || Float.isNaN(floatVal)) { throw new ArithmeticException("Infinite or invalid result"); //$NON-NLS-1$ } } } result = DataTypeManager.convertToRuntimeType(result, expectedType != DataTypeManager.DefaultDataClasses.OBJECT); if (expectedType.isArray() && result instanceof ArrayImpl) { return result; } result = DataTypeManager.transformValue(result, expectedType); if (result != null && expectedType == DataTypeManager.DefaultDataClasses.STRING) { String s = (String)result; if (s.length() > DataTypeManager.MAX_STRING_LENGTH) { return s.substring(0, DataTypeManager.MAX_STRING_LENGTH); } } return result; }
/** * Does a transformation exist between the source and target type? * * @param sourceType * Incoming value type * @param targetType * Outgoing value type * @return True if a transform exists */ public static boolean isTransformable(Class<?> sourceType, Class<?> targetType) { return getTransform(sourceType, targetType) != null; }
public static Object transformValue(Object value, Class<?> targetClass) throws TransformationException { if (value == null) { return value; } return transformValue(value, value.getClass(), targetClass); }
if (DataTypeManager.isTransformable(String.class, runtimeType)) { Transform t = DataTypeManager.getTransform(String.class, runtimeType); value = t.transform(value, runtimeType);
public static int[] getLobIndexes(List<? extends Expression> expressions) { if (expressions == null) { return null; } int[] result = new int[expressions.size()]; int resultIndex = 0; for (int i = 0; i < expressions.size(); i++) { Expression expr = expressions.get(i); if (DataTypeManager.isLOB(expr.getType()) || expr.getType() == DataTypeManager.DefaultDataClasses.OBJECT) { result[resultIndex++] = i; } } if (resultIndex == 0) { return null; } return Arrays.copyOf(result, resultIndex); }
public static Constant convertConstant(String sourceTypeName, String targetTypeName, Constant constant) { if (!DataTypeManager.isTransformable(sourceTypeName, targetTypeName)) { return null; Constant result = getProperlyTypedConstant(constant.getValue(), DataTypeManager.getDataTypeClass(targetTypeName)); if (!DataTypeManager.isTransformable(targetTypeName, sourceTypeName)) { return null;
public void setComponentType(Class<?> baseType) { if (baseType != null) { this.type = DataTypeManager.getArrayType(baseType); } else { this.type = null; } }
@Override public Class<?> getType() { if (type == null) { if (typeString == null) { type = DataTypeManager.DefaultDataClasses.CLOB; } else { type = DataTypeManager.getDataTypeClass(typeString); } } return type; }
static Object convertFromExcelType(final String value, final Class<?> expectedType) throws TranslatorException { if (value == null) { return null; } if (expectedType.isAssignableFrom(String.class)) { return value; } if (expectedType.isAssignableFrom(Blob.class)) { return new BlobType(new BlobImpl(new InputStreamFactory() { @Override public InputStream getInputStream() throws IOException { return new ByteArrayInputStream(value.getBytes()); } })); } else if (expectedType.isAssignableFrom(Clob.class)) { return new ClobType(new ClobImpl(value)); } else if (expectedType.isAssignableFrom(SQLXML.class)) { return new XMLType(new SQLXMLImpl(value.getBytes())); } else if (DataTypeManager.isTransformable(String.class, expectedType)) { try { return DataTypeManager.transformValue(value, expectedType); } catch (TransformationException e) { throw new TranslatorException(e); } } else { throw new TranslatorException(ExcelPlugin.Event.TEIID23003, ExcelPlugin.Util.gs(ExcelPlugin.Event.TEIID23003, expectedType.getName())); } }
@Test public void testMetadataGenerationForAllTypes() throws Exception { Set<String> dataTypes = DataTypeManager.getAllDataTypeNames(); for (String type : dataTypes) { Class<?> typeClass = DataTypeManager.getDataTypeClass(type); MetaDataProcessor processor = new MetaDataProcessor(null, null, "vdb", 1); Map<Integer, Object> columnMetadata = processor.getDefaultColumn("t", "c", typeClass); //$NON-NLS-1$ //$NON-NLS-2$ verifyColumn(columnMetadata, type); } }
private static ColumnSerializer getSerializer(String type, byte version) { ColumnSerializer[] sers = serializers.get(type); if (sers == null) { if (DataTypeManager.isArrayType(type)) { if (version < 2) { return arrayColumnSerializer; } return arrayColumnSerialier2; } return defaultSerializer; } return sers[Math.min(version, sers.length - 1)]; }
@Test public void testCheckConversions() { for (int src = 0; src < dataTypes.length; src++) { for (int tgt =0; tgt < dataTypes.length; tgt++) { char c = conversions[src][tgt]; if (c == 'I') { assertTrue("src="+dataTypes[src]+" target="+dataTypes[tgt]+" should be Implicit", DataTypeManager.isImplicitConversion(dataTypes[src], dataTypes[tgt])); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ assertFalse("src="+dataTypes[src]+" target="+dataTypes[tgt]+" should be not be Explicit", DataTypeManager.isExplicitConversion(dataTypes[src], dataTypes[tgt])); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ assertTrue("src="+dataTypes[src]+" target="+dataTypes[tgt]+" transform should be avaialble", DataTypeManager.isTransformable(dataTypes[src], dataTypes[tgt])); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ } else if (c == 'C') { assertFalse("src="+dataTypes[src]+" target="+dataTypes[tgt]+" should not be Implicit", DataTypeManager.isImplicitConversion(dataTypes[src], dataTypes[tgt])); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ assertTrue("src="+dataTypes[src]+" target="+dataTypes[tgt]+" should be Explicit", DataTypeManager.isExplicitConversion(dataTypes[src], dataTypes[tgt])); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ assertTrue("src="+dataTypes[src]+" target="+dataTypes[tgt]+" transform should be avaialble", DataTypeManager.isTransformable(dataTypes[src], dataTypes[tgt])); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ } else if ( c == 'O' || c == 'N') { assertFalse("src="+dataTypes[src]+" target="+dataTypes[tgt]+" should not be Implicit", DataTypeManager.isImplicitConversion(dataTypes[src], dataTypes[tgt])); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ assertFalse("src="+dataTypes[src]+" target="+dataTypes[tgt]+" should not be Explicit", DataTypeManager.isExplicitConversion(dataTypes[src], dataTypes[tgt])); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ assertFalse("src="+dataTypes[src]+" target="+dataTypes[tgt]+" No transform should be avaialble", DataTypeManager.isTransformable(dataTypes[src], dataTypes[tgt])); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ } } } }
public boolean supportsConvert(int fromType, int toType) throws SQLException { String fromName = JDBCSQLTypeInfo.getTypeName(fromType); String toName = JDBCSQLTypeInfo.getTypeName(toType); if (fromName.equals(toName)) { if (fromName.equals(DataTypeManager.DefaultDataTypes.OBJECT) && fromName != toName) { return false; } return true; } return DataTypeManager.isTransformable(fromName, toName); }