Changeset 7664


Ignore:
Timestamp:
Mar 20, 2019, 1:34:55 PM (3 years ago)
Author:
Nicklas Nordborg
Message:

References #2161: Import data from Excel files

The FlatFileParser can now pass requests for data values on to the actual Excel worksheet object with help of the ExcelData class that is a subclass of Data.

For code that is getting data via the Mapper interface the ColumnMapper has been updated (getInt() and getFloat()). There are some remaining problems:

  • The Mapper interface has no support for date, double or long values
  • A lot of code is not using the Mapper interface but go directly to Data.get() which is returning a string that is then parsed to get a date or number.


So, the Mapper.getValue() and Data.get() methods have been deprecated so that we can more easily find all places in our code that is using those methods. The Data class already has replacement methods in place and we need to updated the Mapper interface as well.

Location:
trunk/src/core/net/sf/basedb
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/core/net/sf/basedb/core/Type.java

    r6875 r7664  
    3535import net.sf.basedb.core.data.TimestampParameterValueData;
    3636import net.sf.basedb.core.hibernate.TypeWrapper;
     37import net.sf.basedb.util.formatter.Formatter;
    3738
    3839import java.io.IOException;
     
    722723 
    723724  /**
     725    Parse a string and return a value of the correct type using a specific
     726    date format for date values, optionally ignoring unparsable dates.
     727    @param value The string value to parse
     728    @param dateFormat The date format, or null to use {@link #parseString(String)}
     729    @param nullIfException TRUE to return null for unparsable date values, or
     730      FALSE to throw an exception
     731    @return a java.lang.Object, or null.
     732    @since 3.15
     733  */
     734  public Object parseString(String value, Formatter<Date> dateFormat, boolean nullIfException)
     735  {
     736    if (value == null)
     737    {
     738      return null;
     739    }
     740    try
     741    {
     742      if (!isTemporal || dateFormat == null)
     743      {
     744        return parseString(value);
     745      }
     746      else
     747      {
     748        value = value.trim();
     749        return dateFormat.parseString(value);
     750      }
     751    }
     752    catch (RuntimeException t)
     753    {
     754      if (nullIfException) return null;
     755      throw t;
     756    }
     757  }
     758 
     759  /**
    724760    Parse an array of strings and try to convert them to values
    725761    of the correct object type.
  • trunk/src/core/net/sf/basedb/util/excel/XlsxToCsvUtil.java

    r7656 r7664  
    55import java.io.InputStream;
    66import java.nio.charset.Charset;
     7import java.text.NumberFormat;
    78import java.util.ArrayList;
    89import java.util.Date;
     
    2223
    2324import net.sf.basedb.core.File;
     25import net.sf.basedb.core.Type;
    2426import net.sf.basedb.util.FileUtil;
    2527import net.sf.basedb.util.encode.EncoderDecoder;
     
    331333  {
    332334    private final Sheet sheet;
     335    private final DataFormatter dataFormat;
     336    private final FormulaEvaluator formulaEval;
    333337
    334338    private final int firstRow;
     
    343347    {
    344348      this.sheet = sheet;
     349      this.dataFormat = new DataFormatter();
     350      this.formulaEval = evaluateFormulas ? workbook.getCreationHelper().createFormulaEvaluator() : null;
    345351     
    346352      this.firstRow = sheet.getFirstRowNum();
     
    422428   
    423429    /**
     430      Get the cell at the specified row and column.
     431      @return A Cell instance or null
     432    */
     433    public Cell getCell(int row, int col)
     434    {
     435      Row r = sheet.getRow(row);
     436      return r == null ? null : r.getCell(col);
     437    }
     438
     439    /**
     440      Get the the cell value as a string. Numeric cells are
     441      are checked if the seem to have a date-like format syntax
     442      (with or without time). If so, the value is formatted with
     443      the date or timestamp formatter, otherwise with the number
     444      formatter. If the required formatter has not been set, the
     445      value is formatted with the built-in formatter from Excel.
     446    */
     447    public String getCellValueAsString(Cell cell)
     448    {
     449      if (cell == null) return null;
     450 
     451      String value = null;
     452      CellType cellType = cell.getCellType();
     453      if (cellType == CellType.FORMULA && evaluateFormulas)
     454      {
     455        cellType = cell.getCachedFormulaResultType();
     456      }
     457      if (cellType == CellType.NUMERIC)
     458      {
     459        boolean isDate = DateUtil.isCellDateFormatted(cell);
     460        if (isDate)
     461        {
     462          String formatString = cell.getCellStyle().getDataFormatString();
     463          boolean hasTimePart = hasTimePart(formatString);
     464          boolean hasDatePart = hasDatePart(formatString);         
     465          Date d = cell.getDateCellValue();
     466          if (hasDatePart && hasTimePart)
     467          {
     468            if (timestampFormat != null) value = timestampFormat.format(d);
     469          }
     470          else if (hasDatePart)
     471          {
     472            if (dateFormat != null) value = dateFormat.format(d);
     473          }
     474          else
     475          {
     476            // Only time part -- let it be handled by the DataFormat
     477          }
     478        }
     479        else
     480        {
     481          if (numberFormat != null)
     482          {
     483            value = numberFormat.format(cell.getNumericCellValue());
     484          }
     485        }
     486      }
     487      if (value == null)
     488      {
     489        value = dataFormat.formatCellValue(cell, formulaEval);
     490      }
     491      return value;
     492    }
     493
     494    /**
     495      Get the cell value as a number. If the cell is a numeric cell, the value is returned
     496      directly, otherwise the given parser is used to parse the string data from cell,
     497      via {@link Type#parseString(String, NumberFormat, boolean)}
     498    */
     499    public Double getCellValueAsNumber(Cell cell, NumberFormat parser, boolean nullIfException)
     500    {
     501      if (cell == null) return null;
     502     
     503      Double value = null;
     504      CellType cellType = cell.getCellType();
     505      if (cellType == CellType.FORMULA && evaluateFormulas)
     506      {
     507        cellType = cell.getCachedFormulaResultType();
     508      }
     509      if (cellType == CellType.NUMERIC)
     510      {
     511        value = cell.getNumericCellValue();
     512      }
     513      else
     514      {
     515        String s = dataFormat.formatCellValue(cell, formulaEval);
     516        value = (Double)Type.DOUBLE.parseString(s, parser, nullIfException);
     517      }
     518      return value;
     519    }
     520   
     521    /**
     522      Get the cell value as a date. If the cell is a numeric cell, the value is returned
     523      directly as if it was a date (the style format string is NOT checked),
     524      otherwise the given parser is used to parse the string data from cell,
     525      via {@link Type#parseString(String, Formatter, boolean)}
     526    */
     527    public Date getCellValueAsDate(Cell cell, Formatter<Date> parser, boolean nullIfException)
     528    {
     529      if (cell == null) return null;
     530     
     531      Date value = null;
     532      CellType cellType = cell.getCellType();
     533      if (cellType == CellType.FORMULA && evaluateFormulas)
     534      {
     535        cellType = cell.getCachedFormulaResultType();
     536      }
     537      if (cellType == CellType.NUMERIC)
     538      {
     539        value = cell.getDateCellValue();
     540      }
     541      else
     542      {
     543        String s = dataFormat.formatCellValue(cell, formulaEval);
     544        value = (Date)Type.DATE.parseString(s, parser, nullIfException);
     545      }
     546      return value;
     547    }
     548   
     549    /**
    424550      Convert the sheet to a CSV and get an InputStream for reading the data.
    425551      Note that the CSV will only contain data for the range of cells between
     
    434560    private void parseToBytes()
    435561    {
    436       DataFormatter data = new DataFormatter();
    437       FormulaEvaluator eval = evaluateFormulas ? workbook.getCreationHelper().createFormulaEvaluator() : null;
    438      
    439562      StringBuilder out = new StringBuilder();
    440563      for (int rowNo = firstRow; rowNo <= lastRow; rowNo++)
    441564      {
    442565        Row row = sheet.getRow(rowNo);
    443         if (row == null || row.getPhysicalNumberOfCells() == 0) continue;
    444         int lastRowCol = writeTrailingColumns ? lastColumn : row.getLastCellNum()-1;  // Note! getLastCellNum() returns index of last cell+1 that contains data!
    445        
    446         for (int colNo = firstColumn; colNo <= lastRowCol; colNo++)
     566        if (row == null || row.getPhysicalNumberOfCells() == 0)
    447567        {
    448           if (colNo > firstColumn) out.append(columnSeparator);
    449           Cell cell = row.getCell(colNo);
    450           String value = null;
    451           if (cell != null)
     568          if (writeTrailingColumns)
    452569          {
    453             CellType cellType = cell.getCellType();
    454             if (cellType == CellType.FORMULA && evaluateFormulas)
     570            for (int colNo = firstColumn; colNo < lastColumn; colNo++)
    455571            {
    456               cellType = cell.getCachedFormulaResultType();
    457             }
    458             if (cellType == CellType.NUMERIC)
    459             {
    460               boolean isDate = DateUtil.isCellDateFormatted(cell);
    461               if (isDate)
    462               {
    463                 String formatString = cell.getCellStyle().getDataFormatString();
    464                 boolean hasTimePart = hasTimePart(formatString);
    465                 boolean hasDatePart = hasDatePart(formatString);         
    466                 Date d = cell.getDateCellValue();
    467                 if (hasDatePart && hasTimePart)
    468                 {
    469                   if (timestampFormat != null) value = timestampFormat.format(d);
    470                 }
    471                 else if (hasDatePart)
    472                 {
    473                   if (dateFormat != null) value = dateFormat.format(d);
    474                 }
    475                 else
    476                 {
    477                   // Only time part -- let it be handled by the DataFormat
    478                 }
    479               }
    480               else
    481               {
    482                 if (numberFormat != null)
    483                 {
    484                   value = numberFormat.format(cell.getNumericCellValue());
    485                 }
    486               }
    487             }
    488             if (value == null)
    489             {
    490               value = data.formatCellValue(cell, eval);
     572              out.append(columnSeparator);
    491573            }
    492574          }
    493           out.append(value == null ? "" : encoder.encode(value));
     575        }
     576        else
     577        {
     578          int lastRowCol = writeTrailingColumns ? lastColumn : row.getLastCellNum()-1;  // Note! getLastCellNum() returns index of last cell+1 that contains data!
     579          for (int colNo = firstColumn; colNo <= lastRowCol; colNo++)
     580          {
     581            if (colNo > firstColumn) out.append(columnSeparator);
     582            Cell cell = row.getCell(colNo);
     583            String value = getCellValueAsString(cell);
     584            out.append(value == null ? "" : encoder.encode(value));
     585          }
    494586        }
    495587        out.append(rowSeparator);
  • trunk/src/core/net/sf/basedb/util/parser/ColFunction.java

    r6898 r7664  
    3434
    3535import net.sf.basedb.core.BaseException;
     36import net.sf.basedb.core.Type;
    3637import net.sf.basedb.util.jep.JepFunction;
    3738
     
    6465  private final ParsePosition pos;
    6566  private FlatFileParser.Data data;
     67  private Type nextValueType;
    6668  private boolean ignoreNonExistingColumns = false;
    6769 
     
    129131    }
    130132    Object argument = stack.pop();
    131     String value = null;
     133    Integer column = null;
    132134    if (argument instanceof Number)
    133135    {
    134       Number column = (Number)argument;
    135       value = data.get(column.intValue());
     136      column = ((Number)argument).intValue();
    136137    }
    137138    else if (argument instanceof String)
    138139    {
    139140      String colName = (String)argument;
    140       Integer column = columnHeaders.get(colName);
     141      column = columnHeaders.get(colName);
    141142      if (column == null) column = findColumn(colName);
    142143      if (column == null)
     
    146147          throw new BaseException("Column '" + colName + "' not found in column headers.");
    147148        }
    148         value = null;
     149      }
     150    }
     151    else
     152    {
     153      throw new ParseException("Invalid parameter type: " + argument + "; expected number");
     154    }
     155   
     156    Object value = null;
     157    if (column != null)
     158    {
     159      if (nextValueType.isNumerical())
     160      {
     161        value = data.getDouble(column, numberFormat, true);
    149162      }
    150163      else
    151164      {
    152         value = column < data.columns() ? data.get(column) : null;
    153       }
    154     }
    155     else
    156     {
    157       throw new ParseException("Invalid parameter type: " + argument + "; expected number");
    158     }
    159     Double d = null;
    160     if (value != null)
    161     {
    162       if (numberFormat == null)
    163       {
    164         try
    165         {
    166           d = Double.valueOf(value);
    167         }
    168         catch (NumberFormatException ex)
    169         {
    170           stack.push(value);
    171           return;
    172         }
    173       }
    174       else
    175       {
    176         pos.setIndex(0);
    177         Number n = numberFormat.parse(value, pos);
    178         if (n == null || pos.getIndex() < value.length())
    179         {
    180           stack.push(value);
    181           return;
    182         }
    183         d = n.doubleValue();
    184       }
    185     }
    186     stack.push(d);
     165        value = data.get(column);
     166      }
     167    }
     168    stack.push(value);
    187169  }
    188170  // -------------------------------------------
     
    198180  }
    199181 
    200   public void setData(FlatFileParser.Data data)
     182  public void setData(FlatFileParser.Data data, Type valueType)
    201183  {
    202184    this.data = data;
     185    this.nextValueType = valueType;
    203186  }
    204187 
  • trunk/src/core/net/sf/basedb/util/parser/ColumnMapper.java

    r6127 r7664  
    2323
    2424import java.text.NumberFormat;
    25 import java.text.ParsePosition;
    2625
    27 import net.sf.basedb.core.Type;
    2826import net.sf.basedb.util.parser.FlatFileParser.Data;
    2927
     
    4341  private final String name;
    4442  private final NumberFormat parser;
    45   private final ParsePosition pos;
    4643  private final boolean nullIfException;
    4744
     
    7269    this.name = name;
    7370    this.parser = parser;
    74     this.pos = parser == null ? null : new ParsePosition(0);
    7571    this.nullIfException = nullIfException;
    7672  }
     
    9389  public Integer getInt(Data data)
    9490  {
    95     Double d = getDouble(getValue(data));
    96     return d == null ? null : d.intValue();
     91    return index < data.columns() ? data.getInt(index, parser, nullIfException) : null;
    9792  }
    9893  @Override
    9994  public Float getFloat(Data data)
    10095  {
    101     Double d = getDouble(getValue(data));
    102     return d == null ? null : d.floatValue();
     96    return index < data.columns() ? data.getFloat(index, parser, nullIfException) : null;
    10397  }
    10498  // -------------------------------------------
     
    114108  }
    115109  // -------------------------------------------
    116  
    117   private Double getDouble(String value)
    118   {
    119     if (value == null) return null;
    120     Double d = null;
    121     if (parser == null)
    122     {
    123       try
    124       {
    125         d = Double.valueOf(value);
    126       }
    127       catch (RuntimeException rex)
    128       {
    129         if (!nullIfException) throw rex;
    130       }
    131     }
    132     else
    133     {
    134       d = (Double)Type.DOUBLE.parseString(value, parser, nullIfException);
    135     }
    136     return d;
    137   }
    138  
     110
    139111}
    140112
  • trunk/src/core/net/sf/basedb/util/parser/FlatFileParser.java

    r7656 r7664  
    3434import java.util.regex.PatternSyntaxException;
    3535
     36import org.apache.poi.ss.usermodel.Cell;
    3637
    3738import java.util.Arrays;
     
    4748import net.sf.basedb.core.BaseException;
    4849import net.sf.basedb.core.Config;
     50import net.sf.basedb.core.Type;
    4951import net.sf.basedb.core.signal.ThreadSignalHandler;
    5052import net.sf.basedb.util.InputStreamTracker;
     
    194196    Name of the Excel sheet to parse if the file is an Excel file.
    195197  */
    196   private String excelSheet;
     198  private String excelSheetName;
     199 
     200  /**
     201    Excel sheet that is currently being parsed.
     202  */
     203  private XlsxToCsvUtil.SheetInfo excelSheet;
    197204 
    198205  /**
     
    575582  public void setExcelSheet(String name)
    576583  {
    577     this.excelSheet = name;
     584    this.excelSheetName = name;
    578585  }
    579586 
     
    584591  public String getExcelSheet()
    585592  {
    586     return excelSheet;
     593    return excelSheetName;
    587594  }
    588595 
     
    631638      }
    632639      List<String> sheets = xlsUtil.getSheetNames();
    633       SheetInfo sheet = null;
    634640      if (sheets.contains(charsetOrSheetName))
    635641      {
    636         sheet = xlsUtil.getSheetAsCsv(charsetOrSheetName);
     642        excelSheet = xlsUtil.getSheetAsCsv(charsetOrSheetName);
    637643      }
    638       else if (sheets.contains(excelSheet))
     644      else if (sheets.contains(excelSheetName))
    639645      {
    640         sheet = xlsUtil.getSheetAsCsv(excelSheet);
     646        excelSheet = xlsUtil.getSheetAsCsv(excelSheetName);
    641647      }
    642648      else
    643649      {
    644650        // Or try to convert to index with 0 as default
    645         sheet = xlsUtil.getSheetAsCsv(Values.getInt(charsetOrSheetName));
     651        excelSheet = xlsUtil.getSheetAsCsv(Values.getInt(charsetOrSheetName));
    646652      }
    647       excelSheet = sheet.getName();
    648       in = sheet.parseToCsv();
     653      excelSheetName = excelSheet.getName();
     654      in = excelSheet.parseToCsv();
    649655    }
    650656    Charset cs = CharsetUtil.getCharset(charsetName);
     
    13151321            {
    13161322              done = true;
    1317               nextData = new Data(parsedLines, parsedDataLines, line, columns, emptyIsNull, nullIsNull);
     1323              if (excelSheet != null)
     1324              {
     1325                nextData = new ExcelData(excelSheet, parsedLines, parsedDataLines, line, columns, emptyIsNull, nullIsNull);
     1326              }
     1327              else
     1328              {
     1329                nextData = new Data(parsedLines, parsedDataLines, line, columns, emptyIsNull, nullIsNull);
     1330              }
    13181331            }
    13191332          }
     
    17781791      @param index The index for the column, starting at 0
    17791792      @return The value in the column
    1780     */
     1793      @deprecated In 3.15, use {@link #getString(int)} instead or one of the
     1794        other getXxx() method to return a given data type directly
     1795    */
     1796    @Deprecated
    17811797    public String get(int index)
     1798    {
     1799      return getString(index);
     1800    }
     1801   
     1802    /**
     1803      The data line as an array of strings.
     1804      @since 2.15
     1805    */
     1806    public String[] data()
     1807    {
     1808      return result;
     1809    }
     1810   
     1811    /**
     1812      Get the value in the specified column.
     1813      @param index The index for the column, starting at 0
     1814      @return The value in the column
     1815    */
     1816    public String getString(int index)
    17821817    {
    17831818      String value = result[index];
     
    17871822   
    17881823    /**
    1789       The data line as an array of strings.
    1790       @since 2.15
    1791     */
    1792     public String[] data()
    1793     {
    1794       return result;
    1795     }
    1796   }
    1797  
     1824      Get the value as an integer. The default implementation parses
     1825      the string value with the given parser. If the source file is
     1826      an Excel file, the numeric value may be retrieved directly.
     1827      @since 3.15
     1828    */
     1829    public Integer getInt(int index, NumberFormat parser, boolean nullIfException)
     1830    {
     1831      return (Integer)Type.INT.parseString(get(index), parser, nullIfException);
     1832    }
     1833
     1834    /**
     1835      Get the value as a long. The default implementation parses
     1836      the string value with the given parser. If the source file is
     1837      an Excel file, the numeric value may be retrieved directly.
     1838      @since 3.15
     1839    */
     1840    public Long getLong(int index, NumberFormat parser, boolean nullIfException)
     1841    {
     1842      return (Long)Type.LONG.parseString(get(index), parser, nullIfException);
     1843    }
     1844   
     1845    /**
     1846      Get the value as a float. The default implementation parses
     1847      the string value with the given parser. If the source file is
     1848      an Excel file, the numeric value may be retrieved directly.
     1849      @since 3.15
     1850    */
     1851    public Float getFloat(int index, NumberFormat parser, boolean nullIfException)
     1852    {
     1853      return (Float)Type.FLOAT.parseString(get(index), parser, nullIfException);
     1854    }
     1855
     1856    /**
     1857      Get the value as a double. The default implementation parses
     1858      the string value with the given parser. If the source file is
     1859      an Excel file, the numeric value may be retrieved directly.
     1860      @since 3.15
     1861    */
     1862    public Double getDouble(int index, NumberFormat parser, boolean nullIfException)
     1863    {
     1864      return (Double)Type.DOUBLE.parseString(get(index), parser, nullIfException);
     1865    }
     1866
     1867    /**
     1868      Get the value as a date. The default implementation parses
     1869      the string value with the given parser. If the source file is
     1870      an Excel file, the date value may be retrieved directly.
     1871      @since 3.15
     1872    */
     1873    public Date getDate(int index, Formatter<Date> parser, boolean nullIfException)
     1874    {
     1875      return (Date)Type.DATE.parseString(get(index), parser, nullIfException);
     1876    }
     1877  }
     1878 
     1879  /**
     1880    Subclass that is used to return data when the source file is an Excel
     1881    file. It will forward all get() methods to retrieve the data directly
     1882    from the Cell item in Excel.
     1883  */
     1884  static class ExcelData
     1885    extends Data
     1886  {
     1887   
     1888    private final SheetInfo sheet;
     1889    private final int rowOffset;
     1890    private final int colOffset;
     1891   
     1892    /**
     1893      Create a new data object.
     1894    */
     1895    ExcelData(SheetInfo sheet, int lineNo, int dataLineNo, String line, String[] columns, boolean emptyIsNull, boolean nullIsNull)
     1896    {
     1897      super(lineNo, dataLineNo, line, columns, emptyIsNull, nullIsNull);
     1898      this.sheet = sheet;
     1899      this.rowOffset = sheet.getFirstRow()-1;
     1900      this.colOffset = sheet.getFirstColumn();
     1901    }
     1902   
     1903    @Override
     1904    public String getString(int index)
     1905    {
     1906      Cell c = sheet.getCell(lineNo()+rowOffset, index+colOffset);
     1907      return sheet.getCellValueAsString(c);
     1908    }
     1909   
     1910    @Override
     1911    public Integer getInt(int index, NumberFormat parser, boolean nullIfException)
     1912    {
     1913      Double d = getDouble(index, parser, nullIfException);
     1914      return d == null ? null : d.intValue();
     1915    }
     1916   
     1917    @Override
     1918    public Long getLong(int index, NumberFormat parser, boolean nullIfException)
     1919    {
     1920      Double d = getDouble(index, parser, nullIfException);
     1921      return d == null ? null : d.longValue();
     1922    }
     1923 
     1924    @Override
     1925    public Float getFloat(int index, NumberFormat parser, boolean nullIfException)
     1926    {
     1927      Double d = getDouble(index, parser, nullIfException);
     1928      return d == null ? null : d.floatValue();
     1929    }
     1930 
     1931    @Override
     1932    public Double getDouble(int index, NumberFormat parser, boolean nullIfException)
     1933    {
     1934      Cell c = sheet.getCell(lineNo()+rowOffset, index+colOffset);
     1935      return sheet.getCellValueAsNumber(c, parser, nullIfException);
     1936    }
     1937 
     1938    @Override
     1939    public Date getDate(int index, Formatter<Date> parser, boolean nullIfException)
     1940    {
     1941      Cell c = sheet.getCell(lineNo()+rowOffset, index+colOffset);
     1942      return sheet.getCellValueAsDate(c, parser, nullIfException);
     1943    }
     1944
     1945  }
    17981946}
  • trunk/src/core/net/sf/basedb/util/parser/JepMapper.java

    r6881 r7664  
    2626import org.nfunk.jep.JEP;
    2727
     28import net.sf.basedb.core.Type;
    2829import net.sf.basedb.util.jep.Jep;
    2930import net.sf.basedb.util.jep.JepFunction;
     
    122123  public String getValue(Data data)
    123124  {
    124     setData(data);
     125    setData(data, Type.STRING);
    125126    // Workaround for bug in JEP error handling
    126127    // See http://sourceforge.net/tracker/index.php?func=detail&atid=382402&aid=1563324&group_id=24711
     
    132133  public Integer getInt(Data data)
    133134  {
    134     setData(data);
     135    setData(data, Type.INT);
    135136    if (parser.hasError()) Jep.clearErrorList(parser);
    136137    return Integer.valueOf((int)parser.getValue());
     
    139140  public Float getFloat(Data data)
    140141  {
    141     setData(data);
     142    setData(data, Type.FLOAT);
    142143    if (parser.hasError()) Jep.clearErrorList(parser);
    143144    return Float.valueOf((float)parser.getValue());
     
    155156  // -------------------------------------------
    156157
    157   private void setData(Data data)
     158  private void setData(Data data, Type valueType)
    158159  {
    159     colFunction.setData(data);
     160    colFunction.setData(data, valueType);
    160161    if (hasLineNo) lineNoFunction.setData(data);
    161162    if (hasDataNo) dataNoFunction.setData(data);
  • trunk/src/core/net/sf/basedb/util/parser/Mapper.java

    r4515 r7664  
    4848    @param data The line of data
    4949    @return A string value
     50    @deprecated In 3.15, use {@link #getString(Data)} instead or
     51      one of the other getXxxx() methods to get a given data type directly
    5052  */
     53  @Deprecated
    5154  public String getValue(Data data);
    5255 
Note: See TracChangeset for help on using the changeset viewer.