Changeset 7668


Ignore:
Timestamp:
Mar 21, 2019, 12:50:52 PM (3 years ago)
Author:
Nicklas Nordborg
Message:

References #2161: Import data from Excel files

Introduced Mapper.getByType() method as a utility method that delegates to one of the other methods depedning on the type parameter. Also added Mapper.getDouble() and Mapper.getLong() for completeness.

Updated the remaining places in the code that uses a mapper.

Location:
trunk/src
Files:
14 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/core/net/sf/basedb/util/parser/ColumnMapper.java

    r7667 r7668  
    6666    @param parser The parser to use or null to use Double.valueOf()
    6767    @since 2.4
     68    @deprecated In 3.15, use {@link ColumnMapper#ColumnMapper(int, String, NumberFormat, Formatter, boolean)} instead
    6869  */
     70  @Deprecated
    6971  public ColumnMapper(int index, String name, NumberFormat parser, boolean nullIfException)
    7072  {
     
    113115  }
    114116  @Override
     117  public Long getLong(Data data)
     118  {
     119    return index < data.columns() ? data.getLong(index, parser, nullIfException) : null;
     120  }
     121  @Override
    115122  public Float getFloat(Data data)
    116123  {
    117124    return index < data.columns() ? data.getFloat(index, parser, nullIfException) : null;
     125  }
     126  @Override
     127  public Double getDouble(Data data)
     128  {
     129    return index < data.columns() ? data.getDouble(index, parser, nullIfException) : null;
    118130  }
    119131  @Override
  • trunk/src/core/net/sf/basedb/util/parser/CompoundMapper.java

    r7667 r7668  
    128128  }
    129129  @Override
     130  public Long getLong(Data data)
     131  {
     132    if (mappers.size() == 1) return mappers.get(0).getLong(data);
     133    String stringValue = getString(data);
     134    Long longValue = null;
     135    if (stringValue != null)
     136    {
     137      longValue = (Long)Type.LONG.parseString(stringValue, parser, nullIfException);
     138    }
     139    return longValue;
     140  }
     141  @Override
    130142  public Float getFloat(Data data)
    131143  {
     
    138150    }
    139151    return floatValue;
     152  }
     153  @Override
     154  public Double getDouble(Data data)
     155  {
     156    if (mappers.size() == 1) return mappers.get(0).getDouble(data);
     157    String stringValue = getString(data);
     158    Double doubleValue = null;
     159    if (stringValue != null)
     160    {
     161      doubleValue = (Double)Type.DOUBLE.parseString(stringValue, parser, nullIfException);
     162    }
     163    return doubleValue;
    140164  }
    141165  @Override
  • trunk/src/core/net/sf/basedb/util/parser/ConstantMapper.java

    r7667 r7668  
    4848  private boolean needToParseNumeric;
    4949  private boolean needToParseDate;
    50   private Float asFloat;
    51   private Integer asInteger;
     50  private Double asDouble;
     51  private Long asLong;
    5252  private Date asDate;
    5353  private RuntimeException parseException;
     
    9696  {
    9797    this.constant = constant.toString();
    98     this.asInteger = constant;
    99     this.asFloat = constant.floatValue();
     98    this.asLong = constant.longValue();
     99    this.asDouble = constant.doubleValue();
    100100    this.parser = null;
    101101    this.needToParseNumeric = false;
     
    108108  {
    109109    this.constant = constant.toString();
    110     this.asFloat = constant;
    111     this.asInteger = constant.intValue();
     110    this.asDouble = constant.doubleValue();
     111    this.asLong = constant.longValue();
    112112    this.parser = null;
    113113    this.needToParseNumeric = false;
     
    121121    this.constant = dateParser != null ? dateParser.format(constant) : DateUtil.formatDate(constant);
    122122    this.asDate = constant;
    123     this.asFloat = null;
    124     this.asInteger = null;
     123    this.asDouble = null;
     124    this.asLong = null;
    125125    this.parser = null;
    126126    this.needToParseNumeric = false;
     
    153153    if (needToParseNumeric) parseNumeric();
    154154    if (parseException != null) throw parseException;
    155     return asInteger;
     155    return asLong == null ? null : asLong.intValue();
     156  }
     157  @Override
     158  public Long getLong(Data data)
     159  {
     160    if (needToParseNumeric) parseNumeric();
     161    if (parseException != null) throw parseException;
     162    return asLong;
    156163  }
    157164  @Override
     
    160167    if (needToParseNumeric) parseNumeric();
    161168    if (parseException != null) throw parseException;
    162     return asFloat;
     169    return asDouble == null ? null : asDouble.floatValue();
     170  }
     171  @Override
     172  public Double getDouble(Data data)
     173  {
     174    if (needToParseNumeric) parseNumeric();
     175    if (parseException != null) throw parseException;
     176    return asDouble;
    163177  }
    164178  @Override
     
    188202    try
    189203    {
    190       asFloat = (Float)Type.FLOAT.parseString(constant, parser, false);
     204      asDouble = (Double)Type.DOUBLE.parseString(constant, parser, false);
    191205    }
    192206    catch (RuntimeException ex)
     
    194208      if (!nullIfException) parseException = ex;
    195209    }
    196     if (asFloat != null)
    197     {
    198       asInteger = asFloat.intValue();
     210    if (asDouble != null)
     211    {
     212      asLong = asDouble.longValue();
    199213    }
    200214  }
  • trunk/src/core/net/sf/basedb/util/parser/CropStringMapper.java

    r7667 r7668  
    7979  }
    8080  @Override
     81  public Long getLong(Data data)
     82  {
     83    return parent.getLong(data);
     84  }
     85  @Override
    8186  public Float getFloat(Data data)
    8287  {
    8388    return parent.getFloat(data);
     89  }
     90  @Override
     91  public Double getDouble(Data data)
     92  {
     93    return parent.getDouble(data);
    8494  }
    8595  @Override
  • trunk/src/core/net/sf/basedb/util/parser/FlatFileParser.java

    r7667 r7668  
    10831083 
    10841084  /**
     1085    @since 3.15
     1086  */
     1087  public boolean getUseNullIfException()
     1088  {
     1089    return useNullIfException;
     1090  }
     1091 
     1092 
     1093  /**
    10851094    Specify if trying to create a mapper with one of the {@link #getMapper(String)}
    10861095    methods for an expression which references a non-existing column should
     
    11661175  public Mapper getMapper(String expression, NumberFormat numberFormat, boolean nullIfException, JepFunction... functions)
    11671176  {
    1168     return getMapper(expression, numberFormat, dateFormat, nullIfException, (JepFunction[])null);
     1177    return getMapper(expression, numberFormat, dateFormat, nullIfException, functions);
    11691178  }
    11701179 
  • trunk/src/core/net/sf/basedb/util/parser/JepMapper.java

    r7667 r7668  
    7474  public JepMapper(String expression, List<String> columnHeaders)
    7575  {
    76     this(expression, columnHeaders, null, false);
    77   }
    78  
     76    this(expression, columnHeaders, null, null, false, (JepFunction[])null);
     77  }
     78 
     79  /**
     80    @deprecated In 3.15, use {@link JepMapper#JepMapper(String, List, NumberFormat, Formatter, boolean, JepFunction...)} instead
     81  */
     82  @Deprecated
    7983  public JepMapper(String expression, List<String> columnHeaders, NumberFormat numberFormat)
    8084  {
    81     this(expression, columnHeaders, numberFormat, false);
    82   }
    83 
     85    this(expression, columnHeaders, numberFormat, null, false, (JepFunction[])null);
     86  }
     87
     88  /**
     89    @deprecated In 3.15, use {@link JepMapper#JepMapper(String, List, NumberFormat, Formatter, boolean, JepFunction...)} instead
     90  */
     91  @Deprecated
    8492  public JepMapper(String expression, List<String> columnHeaders, NumberFormat numberFormat,
    8593      boolean ignoreNonExistingColumns)
     
    9199   
    92100    @since 3.1
    93   */
     101    @deprecated In 3.15, use {@link JepMapper#JepMapper(String, List, NumberFormat, Formatter, boolean, JepFunction...)} instead
     102  */
     103  @Deprecated
    94104  public JepMapper(String expression, List<String> columnHeaders, NumberFormat numberFormat,
    95105    boolean ignoreNonExistingColumns, JepFunction... functions)
    96106  {
    97     this(expression, columnHeaders, numberFormat, null, ignoreNonExistingColumns, (JepFunction[])null);
     107    this(expression, columnHeaders, numberFormat, null, ignoreNonExistingColumns, functions);
    98108  }
    99109
     
    158168  }
    159169  @Override
     170  public Long getLong(Data data)
     171  {
     172    setData(data, Type.LONG);
     173    if (parser.hasError()) Jep.clearErrorList(parser);
     174    return Long.valueOf((long)parser.getValue());
     175  }
     176  @Override
    160177  public Float getFloat(Data data)
    161178  {
     
    163180    if (parser.hasError()) Jep.clearErrorList(parser);
    164181    return Float.valueOf((float)parser.getValue());
     182  }
     183  @Override
     184  public Double getDouble(Data data)
     185  {
     186    setData(data, Type.DOUBLE);
     187    if (parser.hasError()) Jep.clearErrorList(parser);
     188    return parser.getValue();
    165189  }
    166190  @Override
  • trunk/src/core/net/sf/basedb/util/parser/Mapper.java

    r7667 r7668  
    2424import java.util.Date;
    2525
     26import net.sf.basedb.core.Type;
    2627import net.sf.basedb.util.parser.FlatFileParser.Data;
    2728
     
    7273  */
    7374  public Integer getInt(Data data);
     75
     76  /**
     77    Get the value for the line of data as a long.
     78 
     79    @param data The line of data
     80    @return The value as an long
     81    @throws NumberFormatException If the value can't be parsed as an long
     82    @since 3.15
     83  */
     84  public Long getLong(Data data);
    7485 
    7586  /**
     
    8293  public Float getFloat(Data data);
    8394
     95  /**
     96    Get the value for the line of data as a double.
     97 
     98    @param data The line of data
     99    @return The value as a double
     100    @throws NumberFormatException If the value can't be parsed as a double
     101    @since 3.15
     102  */
     103  public Double getDouble(Data data);
     104
     105  /**
     106    Get the value for the line of data as a date.
     107 
     108    @param data The line of data
     109    @return The value as a date
     110    @since 3.15
     111  */
    84112  public Date getDate(Data data);
    85113
     114  @SuppressWarnings("unchecked")
     115  public default <T> T getByType(Data data, Type type)
     116  {
     117    T value = null;
     118    if (type.isNumerical())
     119    {
     120      if (type == Type.DOUBLE) value = (T)getDouble(data);
     121      else if (type == Type.FLOAT) value = (T)getFloat(data);
     122      else if (type == Type.INT) value = (T)getInt(data);
     123      else if (type == Type.LONG) value = (T)getLong(data);
     124    }
     125    else if (type.isTemporal())
     126    {
     127      value = (T)getDate(data);
     128    }
     129    else
     130    {
     131      value = (T)getString(data);
     132    }
     133    return value;
     134  }
     135 
    86136}
  • trunk/src/core/net/sf/basedb/util/parser/NullIfExceptionMapper.java

    r7667 r7668  
    8282  }
    8383  @Override
     84  public Long getLong(Data data)
     85  {
     86    try
     87    {
     88      return parent.getLong(data);
     89    }
     90    catch (Throwable t)
     91    {}
     92    return null;
     93  }
     94  @Override
    8495  public Float getFloat(Data data)
    8596  {
     
    8798    {
    8899      return parent.getFloat(data);
     100    }
     101    catch (Throwable t)
     102    {}
     103    return null;
     104  }
     105  @Override
     106  public Double getDouble(Data data)
     107  {
     108    try
     109    {
     110      return parent.getDouble(data);
    89111    }
    90112    catch (Throwable t)
  • trunk/src/plugins/core/net/sf/basedb/plugins/AbstractFlatFileImporter.java

    r7656 r7668  
    11781178      try
    11791179      {
    1180         new JepMapper(mapExpression.substring(1), new ArrayList<String>(), null, false,
     1180        new JepMapper(mapExpression.substring(1), new ArrayList<String>(), null, null, false,
    11811181          new DefaultItemFunction<Nameable>(null, null, null));
    11821182      }
  • trunk/src/plugins/core/net/sf/basedb/plugins/AnnotationFlatFileImporter.java

    r7666 r7668  
    721721      {
    722722        at = AnnotationType.getById(dc, at.getId());
    723         Mapper mapper = new ColumnMapper(i, column, numberFormat, false);
     723        Type valueType = at.getValueType();
     724        Formatter<Date> df = null;
     725        NumberFormat nf = null;
     726        if (valueType.isTemporal()) df = valueType == Type.TIMESTAMP ? timestampFormatter : dateFormatter;
     727        if (valueType.isNumerical()) nf = numberFormat;
     728        Mapper mapper = new ColumnMapper(i, column, nf, df, false);
    724729        if (cropStrings && at.getValueType() == Type.STRING && at.getMaxLength() != null)
    725730        {
     
    816821        AnnotationType at = entry.getValue();
    817822        Type valueType = at.getValueType();
    818         String sValue = mapper.getValue(data);
    819823
    820824        Object annotationValue = null;
     
    826830          {
    827831            // Case and leading/trailing whitespace are ignore for enumerated string annotations
     832            String sValue = mapper.getString(data);
    828833            String enumValue = at.findValue(sValue, true, true);
    829             if (enumValue != null) sValue = enumValue;
    830           }
    831           if (at.supportUnits())
    832           {
    833             // Check if the value is followed by a unit
     834            if (enumValue != null) annotationValue = enumValue;
     835          }
     836          else if (at.supportUnits())
     837          {
     838            // If a unit is used data is a string so we need to check that
     839            String sValue = mapper.getString(data);
    834840            String[] valueAndUnit = UnitUtil.splitValueWithUnit(sValue);
    835             if (valueAndUnit != null)
     841            if (valueAndUnit != null && valueAndUnit[1] != null)
    836842            {
    837843              String unitSymbol = valueAndUnit[1];
    838               if (unitSymbol != null)
     844              // Yes.. there is a unit, look it up
     845              unit = unitCache.findUnit(at.getQuantity(), unitSymbol);
     846              if (unit == null)
    839847              {
    840                 // Yes.. there is a unit, look it up
    841                 unit = unitCache.findUnit(at.getQuantity(), unitSymbol);
    842                 if (unit == null)
    843                 {
    844                   // The unit doesn't exists
    845                   throw new NumberFormatException("Unknown unit for value: " + sValue);
    846                 }
     848                // The unit doesn't exists
     849                throw new NumberFormatException("Unknown unit for value: " + sValue);
    847850              }
    848               else
    849               {
    850                 // No unit specified, use the default unit
    851                 unit = at.getDefaultUnit();
    852               }
    853               sValue = valueAndUnit[0];
     851              annotationValue = Type.DOUBLE.parseString(valueAndUnit[0], numberFormat, false);
    854852            }
    855           }
    856           if (unit != null)
    857           {
    858             annotationValue = Type.DOUBLE.parseString(sValue, numberFormat, false);
    859           }
    860           else if (valueType == Type.DATE)
    861           {
    862             annotationValue = dateFormatter.parseString(sValue);
    863           }
    864           else if (valueType == Type.TIMESTAMP)
    865           {
    866             annotationValue = timestampFormatter.parseString(sValue);
     853            else
     854            {
     855              // No unit specified, use the default unit and get the type-specific value from the mapper
     856              unit = at.getDefaultUnit();
     857              annotationValue = mapper.getByType(data, valueType);
     858            }
    867859          }
    868860          else
    869861          {
    870             annotationValue = valueType.parseString(sValue, numberFormat, false);
     862            annotationValue = mapper.getByType(data, valueType);
    871863          }
    872864          if (annotationValue != null)
  • trunk/src/plugins/core/net/sf/basedb/plugins/IlluminaRawDataImporter.java

    r7666 r7668  
    2626import java.util.Arrays;
    2727import java.util.Collections;
     28import java.util.Date;
    2829import java.util.HashMap;
    2930import java.util.HashSet;
     
    8283import net.sf.basedb.util.Coordinate;
    8384import net.sf.basedb.util.error.SimpleErrorHandler;
     85import net.sf.basedb.util.formatter.Formatter;
    8486import net.sf.basedb.util.fuzzy.StringMatcher;
    8587import net.sf.basedb.util.parser.ColumnMapper;
     
    357359  private int numInserted;
    358360  private int numRawBioAssays;
    359   private NumberFormat numberFormat;
    360361  private boolean nullIfException;
    361362  private boolean verifyColumns;
     
    431432    this.ffp = ffp;
    432433    this.illumina = RawDataTypes.getSafeRawDataType("illumina");
    433     this.numberFormat = ffp.getDefaultNumberFormat();
    434434    this.headerLines = new LinkedList<Line>();
    435435    this.experiment = job.getValue("experiment");
     
    451451    // Setup error handling
    452452    this.nullIfException = "null".equals(getErrorOption("numberFormatError"));
     453    ffp.setUseNullIfException(nullIfException);
    453454    this.verifyColumns = "fail".equals(getErrorOption("invalidColumnsError"));
    454455    if (design == null)
     
    543544        RawDataProperty ep = entry.getKey();
    544545        Mapper m = entry.getValue();
    545         raw.setExtended(ep.getName(), ep.parseString(m.getValue(data), numberFormat, nullIfException));
     546        raw.setExtended(ep.getName(), m.getByType(data, ep.getType()));
    546547      }
    547548      holder.batcher.insert(raw, externalId, externalId);
     
    934935    private void createMappers(RawDataType illumina, FlatFileParser ffp)
    935936    {
     937      NumberFormat nf = ffp.getDefaultNumberFormat();
     938      Formatter<Date> df = ffp.getDefaultDateFormat();
     939      boolean nullIfException = ffp.getUseNullIfException();
     940     
    936941      for (RawDataProperty rawProperty : illumina.getProperties())
    937942      {
     
    940945        if (colIndex != null)
    941946        {
    942           mappers.put(rawProperty, new ColumnMapper(colIndex, colName));
     947          mappers.put(rawProperty, new ColumnMapper(colIndex, colName, nf, df, nullIfException));
    943948        }
    944949      }
  • trunk/src/plugins/core/net/sf/basedb/plugins/RawDataFlatFileImporter.java

    r7666 r7668  
    8383import net.sf.basedb.core.Job;
    8484
    85 import java.text.NumberFormat;
    8685import java.util.ArrayList;
    8786import java.util.Arrays;
     
    275274  private DbControl dc;
    276275  private FlatFileParser ffp;
    277   private NumberFormat numberFormat;
    278276  private boolean nullIfException;
    279277  private boolean continueAfterError;
     
    707705    batcher = rawBioAssay.getRawDataBatcher(fiMethod, job.getJob());
    708706    this.ffp = ffp;
    709     this.numberFormat = ffp.getDefaultNumberFormat();
     707    // Set up error handling
    710708    this.nullIfException = "null".equals(job.getValue("numberFormatError"));
    711    
    712     // Set up error handling
     709    ffp.setUseNullIfException(nullIfException);
    713710    if (rawBioAssay.hasArrayDesign())
    714711    {
     
    851848      RawDataProperty ep = entry.getKey();
    852849      Mapper m = entry.getValue();
    853       raw.setExtended(ep.getName(), ep.parseString(m.getValue(data), numberFormat, nullIfException));
     850      raw.setExtended(ep.getName(), m.getByType(data, ep.getType()));
    854851    }
    855852    batcher.insert(raw, externalId, featureId);
  • trunk/src/plugins/core/net/sf/basedb/plugins/ReporterFlatFileImporter.java

    r7666 r7668  
    6868import net.sf.basedb.util.parser.Mapper;
    6969
    70 import java.text.NumberFormat;
    7170import java.util.Collection;
    7271import java.util.EnumSet;
     
    421420  private Set<String> deleted;
    422421  private FlatFileParser ffp;
    423   private NumberFormat numberFormat;
    424422  private boolean nullIfException;
    425423  private boolean failIfUsed;
     
    456454    }
    457455    this.ffp = ffp;
    458     this.numberFormat = ffp.getDefaultNumberFormat();
    459456    this.nullIfException = "null".equals(job.getValue("numberFormatError"));
     457    ffp.setUseNullIfException(nullIfException);
    460458    String reporterIsUsedError = getErrorOption("reporterIsUsedError");
    461459    this.failIfUsed = "fail".equals(reporterIsUsedError);
     
    670668            ExtendedProperty ep = entry.getKey();
    671669            Mapper m = entry.getValue();
    672             reporter.setExtended(ep.getName(), ep.parseString(m.getValue(data),
    673               numberFormat, nullIfException));
     670            reporter.setExtended(ep.getName(), m.getByType(data, ep.getType()));
    674671          }
    675672          if (currentId != 0)
  • trunk/src/plugins/core/net/sf/basedb/plugins/batchimport/AnnotationTypeImporter.java

    r7667 r7668  
    507507    if (minValueMapper != null && valueType.isNumerical())
    508508    {
    509       String minValue = minValueMapper.getValue(data);
    510509      if (valueType == Type.INT || valueType == Type.LONG)
    511510      {
    512511       
    513         at.setMinValueLong((Long)Type.LONG.parseString(minValue, numberFormat, false));
     512        at.setMinValueLong(minValueMapper.getLong(data));
    514513      }
    515514      else
    516515      {
    517         at.setMinValueDouble((Double)Type.DOUBLE.parseString(minValue, numberFormat, false));
     516        at.setMinValueDouble(minValueMapper.getDouble(data));
    518517      }
    519518    }
    520519    if (maxValueMapper != null && valueType.isNumerical())
    521520    {
    522       String maxValue = maxValueMapper.getValue(data);
    523521      if (valueType == Type.INT || valueType == Type.LONG)
    524522      {
    525         at.setMaxValueLong((Long)Type.LONG.parseString(maxValue, numberFormat, false));
     523        at.setMaxValueLong(maxValueMapper.getLong(data));
    526524      }
    527525      else
    528526      {
    529         at.setMaxValueDouble((Double)Type.DOUBLE.parseString(maxValue, numberFormat, false));
     527        at.setMaxValueDouble(maxValueMapper.getDouble(data));
    530528      }
    531529    }
Note: See TracChangeset for help on using the changeset viewer.