Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package de.zalando.typemapper.core;
  
  import java.sql.ResultSet;
  
  import java.util.List;
  import java.util.Map;
  
 
 
 
 
 
 public class TypeMapper<ITEM> implements ParameterizedRowMapper<ITEM> {
 
     private static final Logger LOG = LoggerFactory.getLogger(TypeMapper.class);
 
     private final Class<ITEM> resultClass;
     private final List<Mappingmappings;
 
     TypeMapper(final Class<ITEM> resultClass) {
         this. = resultClass;
          = Mapping.getMappingsForClass(this.);
     }
 
     @SuppressWarnings({ "unchecked""rawtypes" })
     @Override
     public ITEM mapRow(final ResultSet setfinal int countthrows SQLException {
         ITEM result = null;
         try {
 
             Class<ITEM> resultClass = getResultClass();
 
             if (resultClass.isEnum()) { // Since Enums can't be instantiated, they need to be processed differently
                 .debug("{} is an Enum"resultClass.getName());
 
                 String enumValue = set.getString(1);
 
                 if (enumValue != null) {
                     result = (ITEM) Enum.valueOf((Class<? extends Enum>) resultClassset.getString(1));
                 }
             } else {
                 final ResultTree resultTree = extractResultTree(set);
                 result = resultClass.newInstance();
                 fillObject(resultresultTree);
             }
         } catch (final InstantiationException | IllegalAccessException e) {
             throw new SQLException(getResultClass() + " has no public nullary constructor: "e);
         }
 
         return result;
     }
 
     private ResultTree extractResultTree(final ResultSet setthrows SQLException {
         .trace("Extracting result tree");
 
         // cast to obtain more information from the result set.
         final Jdbc4ResultSet pgSet = (Jdbc4ResultSetset;
         final ResultSetMetaData rsMetaData = pgSet.getMetaData();
 
         final ResultTree tree = new ResultTree();
 
         for (int i = 1; i <= rsMetaData.getColumnCount(); i++) {
             final int typeId = pgSet.getColumnOID(i);
             DbResultNode node = null;
 
             final Object obj = pgSet.getObject(i);
             final String name = rsMetaData.getColumnName(i);
 
             // TODO pribeiro We should use polymorphism here. Build like a chain
             if ((obj instanceof PGobject) && ((PGobjectobj).getType().equals("record")) {
                 final PGobject pgObj = (PGobjectobj;
                 final DbFunction function = DbFunctionRegister.getFunction(namepgSet.getStatement().getConnection());
                 List<StringfieldValues;
                 try {
                     fieldValues = ParseUtils.postgresROW2StringList(pgObj.getValue());
                 } catch (final RowParserException e) {
                     throw new SQLException(e);
                }
                int j = 1;
                for (final String fieldValue : fieldValues) {
                    final DbTypeField fieldDef = function.getFieldByPos(j);
                    DbResultNode currentNode = null;
                    if (fieldDef.getType().equals("USER-DEFINED")) {
                        currentNode = new ObjectResultNode(fieldValuefieldDef.getName(), fieldDef.getTypeName(),
                                fieldDef.getTypeId(), pgSet.getStatement().getConnection());
                    } else if (fieldDef.getType().equals("ARRAY")) {
                        currentNode = new ArrayResultNode(fieldDef.getName(), fieldValue,
                                fieldDef.getTypeName().substring(1), fieldDef.getTypeId(),
                                pgSet.getStatement().getConnection());
                    } else {
                        currentNode = new SimpleResultNode(fieldValuefieldDef.getName());
                    }
                    tree.addChild(currentNode);
                    j++;
                }
                i++;
                continue;
            } else if (obj instanceof Map) {
                node = new MapResultNode((Map<StringString>) objname);
            } else if (obj instanceof PGobject) {
                final PGobject pgObj = (PGobjectobj;
                node = new ObjectResultNode(pgObj.getValue(), namepgObj.getType(), typeId,
                        pgSet.getStatement().getConnection());
            } else if (obj instanceof Jdbc4Array) {
                final Jdbc4Array arrayObj = (Jdbc4Arrayobj;
                // TODO pribeiro jdbc driver lacks support for arrays of user defined types. We should whether
                // implement the missing feature in driver or use the current approach (parse string).
                final String typeName = arrayObj.getBaseTypeName();
                final String value = arrayObj.toString();
                node = new ArrayResultNode(namevaluetypeNametypeIdpgSet.getStatement().getConnection());
            } else {
                node = new SimpleResultNode(objname);
            }
            tree.addChild(node);
        }
        .trace("Extracted ResultTree: {}"tree);
        return tree;
    }
    private void fillObject(final Object resultfinal ResultTree treethrows SQLException {
        for (final Mapping mapping : getMappings()) {
            try {
                final DbResultNode node = tree.getChildByName(mapping.getName());
                // TODO pribeiro we need to distinguish between null value and a mapping not defined in the tree
                if (node == null) {
                    // this may be okay - if any return value is NULL, we will reach this path.
                    // to classify and mark this as an error, we need more information.
                    .trace("Could not map property {} of class {}: field not in result tree, field may be nullable.",
                        mapping.getName(), .getSimpleName());
                    continue;
                }
                if (. != node.getNodeType() && node.getValue() == null) {
                    if (mapping.isOptionalField()) {
                        mapping.map(resultnull);
                    }
                }
                // TODO pribeiro we should use polymorphism instead. Build like a chain.
                if (. == node.getNodeType()) {
                    final String fieldStringValue = node.getValue();
                    final Object value = mapping.getFieldMapper().mapField(fieldStringValuemapping.getFieldClass());
                    mapping.map(resultvalue);
                } else if (. == node.getNodeType()) {
                    // TODO all fields are being converted to String and reverted later. The API forces this approach
                    // (DbResultNode.getValue). This should be improved because it's just causing overhead. The driver
                    // can convert at least the basic types so we should reuse this logic. Result tree should be
                    // improved.
                    // Refactor the if/else statements to a more object-based or polymorphic solution.
                    final Object value = ((MapResultNodenode).getMap();
                    mapping.map(resultvalue);
                } else if (. == node.getNodeType()) {
                    final Object value = ObjectFieldMapper.mapFromDbObjectNode(mapping.getFieldClass(),
                            (ObjectResultNodenodemapping);
                    mapping.map(resultvalue);
                } else if (. == node.getNodeType()) {
                    final Object value = ArrayFieldMapper.mapField(mapping.getField(), (ArrayResultNodenode);
                    mapping.map(resultvalue);
                }
            } catch (final Exception e) {
                .error("Could not map property {} of class {}",
                    new Object[] {mapping.getName(), .getSimpleName(), e});
            }
        }
    }
    public Class<ITEM> getResultClass() {
        return ;
    }
    public List<MappinggetMappings() {
        return ;
    }
New to GrepCode? Check out our FAQ X