embulk-parser-poi_excel 0.1.5 → 0.1.12

data/src/main/java/org/embulk/parser/poi_excel/PoiExcelColumnValueType.java

@@ -1,5 +1,7 @@
 package org.embulk.parser.poi_excel;
 
+import org.embulk.parser.poi_excel.bean.record.RecordType;
+
 public enum PoiExcelColumnValueType {
 	/** cell value */
 	CELL_VALUE(true, true),
@@ -11,12 +13,32 @@ public enum PoiExcelColumnValueType {
 	CELL_FONT(true, false),
 	/** cell comment */
 	CELL_COMMENT(true, false),
+	/** cell type */
+	CELL_TYPE(true, false),
+	/** cell CachedFormulaResultType */
+	CELL_CACHED_TYPE(true, false),
 	/** sheet name */
 	SHEET_NAME(false, false),
 	/** row number (1 origin) */
-	ROW_NUMBER(false, false),
+	ROW_NUMBER(false, false) {
+		@Override
+		public boolean useCell(RecordType recordType) {
+			if (recordType == RecordType.COLUMN) {
+				return true;
+			}
+			return super.useCell(recordType);
+		}
+	},
 	/** column number (1 origin) */
-	COLUMN_NUMBER(true, false),
+	COLUMN_NUMBER(true, false) {
+		@Override
+		public boolean useCell(RecordType recordType) {
+			if (recordType == RecordType.ROW) {
+				return true;
+			}
+			return super.useCell(recordType);
+		}
+	},
 	/** constant */
 	CONSTANT(false, false);
 
@@ -28,7 +50,7 @@ public enum PoiExcelColumnValueType {
 		this.nextIndex = nextIndex;
 	}
 
-	public boolean useCell() {
+	public boolean useCell(RecordType recordType) {
 		return useCell;
 	}
 

data/src/main/java/org/embulk/parser/poi_excel/PoiExcelParserPlugin.java

@@ -2,12 +2,14 @@ package org.embulk.parser.poi_excel;
 
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
+import java.util.regex.Pattern;
 
 import org.apache.poi.EncryptedDocumentException;
 import org.apache.poi.openxml4j.exceptions.InvalidFormatException;
-import org.apache.poi.ss.usermodel.Row;
 import org.apache.poi.ss.usermodel.Sheet;
 import org.apache.poi.ss.usermodel.Workbook;
 import org.apache.poi.ss.usermodel.WorkbookFactory;
@@ -17,6 +19,8 @@ import org.embulk.config.ConfigException;
 import org.embulk.config.ConfigSource;
 import org.embulk.config.Task;
 import org.embulk.config.TaskSource;
+import org.embulk.parser.poi_excel.bean.PoiExcelSheetBean;
+import org.embulk.parser.poi_excel.bean.record.PoiExcelRecord;
 import org.embulk.parser.poi_excel.visitor.PoiExcelColumnVisitor;
 import org.embulk.parser.poi_excel.visitor.PoiExcelVisitorFactory;
 import org.embulk.parser.poi_excel.visitor.PoiExcelVisitorValue;
@@ -66,6 +70,10 @@ public class PoiExcelParserPlugin implements ParserPlugin {
 
 	public interface SheetCommonOptionTask extends Task, ColumnCommonOptionTask {
 
+		@Config("record_type")
+		@ConfigDefault("null")
+		public Optional<String> getRecordType();
+
 		@Config("skip_header_lines")
 		@ConfigDefault("null")
 		public Optional<Integer> getSkipHeaderLines();
@@ -88,11 +96,30 @@ public class PoiExcelParserPlugin implements ParserPlugin {
 		@ConfigDefault("null")
 		public Optional<String> getValueType();
 
-		// A,B,... or number(1 origin)
+		// same as cell_column
 		@Config("column_number")
 		@ConfigDefault("null")
 		public Optional<String> getColumnNumber();
 
+		public static final String CELL_COLUMN = "cell_column";
+
+		// A,B,... or number(1 origin)
+		@Config(CELL_COLUMN)
+		@ConfigDefault("null")
+		public Optional<String> getCellColumn();
+
+		public static final String CELL_ROW = "cell_row";
+
+		// number(1 origin)
+		@Config(CELL_ROW)
+		@ConfigDefault("null")
+		public Optional<String> getCellRow();
+
+		// A1,B2,... or Sheet1!A1
+		@Config("cell_address")
+		@ConfigDefault("null")
+		public Optional<String> getCellAddress();
+
 		// use when value_type=cell_style, cell_font, ...
 		@Config("attribute_name")
 		@ConfigDefault("null")
@@ -100,11 +127,19 @@ public class PoiExcelParserPlugin implements ParserPlugin {
 	}
 
 	public interface ColumnCommonOptionTask extends Task {
+		// format of numeric(double) to string
+		@Config("numeric_format")
+		@ConfigDefault("null")
+		public Optional<String> getNumericFormat();
 
 		// search merged cell if cellType=BLANK
 		@Config("search_merged_cell")
 		@ConfigDefault("null")
-		public Optional<Boolean> getSearchMergedCell();
+		public Optional<String> getSearchMergedCell();
+
+		@Config("formula_handling")
+		@ConfigDefault("null")
+		public Optional<String> getFormulaHandling();
 
 		@Config("formula_replace")
 		@ConfigDefault("null")
@@ -166,9 +201,60 @@ public class PoiExcelParserPlugin implements ParserPlugin {
 					throw new RuntimeException(e);
 				}
 
-				run(task, schema, workbook, sheetNames, output);
+				List<String> list = resolveSheetName(workbook, sheetNames);
+				if (log.isDebugEnabled()) {
+					log.debug("resolved sheet names={}", list);
+				}
+				run(task, schema, workbook, list, output);
+			}
+		}
+	}
+
+	private List<String> resolveSheetName(Workbook workbook, List<String> sheetNames) {
+		Set<String> set = new LinkedHashSet<>();
+		for (String s : sheetNames) {
+			if (s.contains("*") || s.contains("?")) {
+				int length = s.length();
+				StringBuilder sb = new StringBuilder(length * 2);
+				StringBuilder buf = new StringBuilder(32);
+				for (int i = 0; i < length;) {
+					int c = s.codePointAt(i);
+					switch (c) {
+					case '*':
+						if (buf.length() > 0) {
+							sb.append(Pattern.quote(buf.toString()));
+							buf.setLength(0);
+						}
+						sb.append(".*");
+						break;
+					case '?':
+						if (buf.length() > 0) {
+							sb.append(Pattern.quote(buf.toString()));
+							buf.setLength(0);
+						}
+						sb.append(".");
+						break;
+					default:
+						buf.appendCodePoint(c);
+						break;
+					}
+					i += Character.charCount(c);
+				}
+				if (buf.length() > 0) {
+					sb.append(Pattern.quote(buf.toString()));
+				}
+				String regex = sb.toString();
+				for (Sheet sheet : workbook) {
+					String name = sheet.getSheetName();
+					if (name.matches(regex)) {
+						set.add(name);
+					}
+				}
+			} else {
+				set.add(s);
 			}
 		}
+		return new ArrayList<>(set);
 	}
 
 	protected void run(PluginTask task, Schema schema, Workbook workbook, List<String> sheetNames, PageOutput output) {
@@ -189,22 +275,27 @@ public class PoiExcelParserPlugin implements ParserPlugin {
 				log.info("sheet={}", sheetName);
 				PoiExcelVisitorFactory factory = newPoiExcelVisitorFactory(task, schema, sheet, pageBuilder);
 				PoiExcelColumnVisitor visitor = factory.getPoiExcelColumnVisitor();
-				final int skipHeaderLines = factory.getVisitorValue().getSheetBean().getSkipHeaderLines();
+				PoiExcelSheetBean sheetBean = factory.getVisitorValue().getSheetBean();
+				final int skipHeaderLines = sheetBean.getSkipHeaderLines();
+
+				PoiExcelRecord record = sheetBean.getRecordType().newPoiExcelRecord();
+				record.initialize(sheet, skipHeaderLines);
+				visitor.setRecord(record);
 
 				int count = 0;
-				for (Row row : sheet) {
-					if (row.getRowNum() < skipHeaderLines) {
-						continue;
-					}
+				for (; record.exists(); record.moveNext()) {
+					record.logStart();
 
-					visitor.setRow(row);
-					schema.visitColumns(visitor);
+					schema.visitColumns(visitor); // use record
 					pageBuilder.addRecord();
 
 					if (++count >= flushCount) {
+						log.trace("flush");
 						pageBuilder.flush();
 						count = 0;
 					}
+
+					record.logEnd();
 				}
 				pageBuilder.flush();
 			}

data/src/main/java/org/embulk/parser/poi_excel/bean/PoiExcelColumnBean.java

@@ -5,12 +5,16 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
+import org.apache.poi.ss.util.CellReference;
 import org.embulk.config.ConfigException;
 import org.embulk.parser.poi_excel.PoiExcelColumnValueType;
 import org.embulk.parser.poi_excel.PoiExcelParserPlugin.ColumnCommonOptionTask;
 import org.embulk.parser.poi_excel.PoiExcelParserPlugin.ColumnOptionTask;
 import org.embulk.parser.poi_excel.PoiExcelParserPlugin.FormulaReplaceTask;
 import org.embulk.parser.poi_excel.bean.PoiExcelColumnBean.ErrorStrategy.Strategy;
+import org.embulk.parser.poi_excel.bean.util.PoiExcelCellAddress;
+import org.embulk.parser.poi_excel.bean.util.SearchMergedCell;
+import org.embulk.parser.poi_excel.visitor.util.MergedRegionFinder;
 import org.embulk.spi.Column;
 
 import com.google.common.base.Optional;
@@ -98,6 +102,12 @@ public class PoiExcelColumnBean {
 	}
 
 	public Optional<String> getColumnNumber() {
+		for (ColumnOptionTask task : columnTaskList) {
+			Optional<String> option = task.getCellColumn();
+			if (option.isPresent()) {
+				return option;
+			}
+		}
 		for (ColumnOptionTask task : columnTaskList) {
 			Optional<String> option = task.getColumnNumber();
 			if (option.isPresent()) {
@@ -107,6 +117,40 @@ public class PoiExcelColumnBean {
 		return Optional.absent();
 	}
 
+	public Optional<String> getRowNumber() {
+		for (ColumnOptionTask task : columnTaskList) {
+			Optional<String> option = task.getCellRow();
+			if (option.isPresent()) {
+				return option;
+			}
+		}
+		return Optional.absent();
+	}
+
+	private Optional<PoiExcelCellAddress> cellAddress;
+
+	public PoiExcelCellAddress getCellAddress() {
+		if (cellAddress == null) {
+			this.cellAddress = initializeCellAddress();
+		}
+		return cellAddress.orNull();
+	}
+
+	protected Optional<PoiExcelCellAddress> initializeCellAddress() {
+		for (ColumnOptionTask task : columnTaskList) {
+			Optional<String> option = task.getCellAddress();
+			if (option.isPresent()) {
+				CellReference ref = new CellReference(option.get());
+				return Optional.of(new PoiExcelCellAddress(ref));
+			}
+		}
+		return Optional.absent();
+	}
+
+	public void setCellAddress(CellReference ref) {
+		this.cellAddress = Optional.of(new PoiExcelCellAddress(ref));
+	}
+
 	protected abstract class CacheValue<T> {
 		private T value;
 
@@ -231,23 +275,105 @@ public class PoiExcelColumnBean {
 		return attributeName.get();
 	}
 
-	private CacheValue<Boolean> searchMergedCell = new CacheValue<Boolean>() {
+	private CacheValue<String> numericFormat = new CacheValue<String>() {
+
+		@Override
+		protected Optional<String> getTaskValue(ColumnCommonOptionTask task) {
+			return task.getNumericFormat();
+		}
+
+		@Override
+		protected String getDefaultValue() {
+			return "";
+		}
+	};
+
+	public String getNumericFormat() {
+		return numericFormat.get();
+	}
+
+	private CacheValue<SearchMergedCell> searchMergedCell = new CacheValue<SearchMergedCell>() {
 
 		@Override
-		protected Optional<Boolean> getTaskValue(ColumnCommonOptionTask task) {
-			return task.getSearchMergedCell();
+		protected Optional<SearchMergedCell> getTaskValue(ColumnCommonOptionTask task) {
+			Optional<String> option = task.getSearchMergedCell();
+			String value = option.or("null").trim();
+			switch (value.toLowerCase()) {
+			case "null":
+				return Optional.absent();
+			case "true": // compatibility ver 0.1.7
+				return Optional.of(getDefaultValue());
+			case "false": // compatibility ver 0.1.7
+				return Optional.of(SearchMergedCell.NONE);
+			default:
+				break;
+			}
+			try {
+				return Optional.of(SearchMergedCell.valueOf(value.toUpperCase()));
+			} catch (Exception e) {
+				List<String> list = new ArrayList<>();
+				for (SearchMergedCell s : SearchMergedCell.values()) {
+					list.add(s.name().toLowerCase());
+				}
+				throw new ConfigException(MessageFormat.format("illegal search_merged_cell={0}. expected={1}", value,
+						list), e);
+			}
 		}
 
 		@Override
-		protected Boolean getDefaultValue() {
-			return true;
+		protected SearchMergedCell getDefaultValue() {
+			return SearchMergedCell.HASH_SEARCH;
 		}
 	};
 
-	public boolean getSearchMergedCell() {
+	public SearchMergedCell getSearchMergedCell() {
 		return searchMergedCell.get();
 	}
 
+	private MergedRegionFinder mergedRegionFinder;
+
+	public MergedRegionFinder getMergedRegionFinder() {
+		if (mergedRegionFinder == null) {
+			this.mergedRegionFinder = getSearchMergedCell().getMergedRegionFinder();
+		}
+		return mergedRegionFinder;
+	}
+
+	public enum FormulaHandling {
+		EVALUATE, CASHED_VALUE
+	}
+
+	private CacheValue<FormulaHandling> formulaHandling = new CacheValue<FormulaHandling>() {
+
+		@Override
+		protected Optional<FormulaHandling> getTaskValue(ColumnCommonOptionTask task) {
+			Optional<String> option = task.getFormulaHandling();
+			String value = option.or("null");
+			if ("null".equalsIgnoreCase(value)) {
+				return Optional.absent();
+			}
+			try {
+				return Optional.of(FormulaHandling.valueOf(value.trim().toUpperCase()));
+			} catch (Exception e) {
+				List<String> list = new ArrayList<>();
+				for (FormulaHandling s : FormulaHandling.values()) {
+					list.add(s.name().toLowerCase());
+				}
+				throw new ConfigException(MessageFormat.format("illegal formula_handling={0}. expected={1}", value,
+						list), e);
+			}
+		}
+
+		@Override
+		protected FormulaHandling getDefaultValue() {
+			return FormulaHandling.EVALUATE;
+		}
+	};
+
+	public FormulaHandling getFormulaHandling() {
+		return formulaHandling.get();
+	}
+
 	private CacheValue<List<FormulaReplaceTask>> formulaReplace = new CacheValue<List<FormulaReplaceTask>>() {
 
 		@Override

data/src/main/java/org/embulk/parser/poi_excel/bean/PoiExcelColumnIndex.java

@@ -7,7 +7,10 @@ import java.util.Map;
 
 import org.apache.poi.ss.util.CellReference;
 import org.embulk.parser.poi_excel.PoiExcelColumnValueType;
+import org.embulk.parser.poi_excel.PoiExcelParserPlugin.ColumnOptionTask;
 import org.embulk.parser.poi_excel.PoiExcelParserPlugin.PluginTask;
+import org.embulk.parser.poi_excel.bean.record.RecordType;
+import org.embulk.parser.poi_excel.bean.util.PoiExcelCellAddress;
 import org.embulk.spi.Column;
 import org.embulk.spi.Exec;
 import org.embulk.spi.Schema;
@@ -18,68 +21,105 @@ import com.google.common.base.Optional;
 public class PoiExcelColumnIndex {
 	private final Logger log = Exec.getLogger(getClass());
 
+	protected final RecordType recordType;
 	protected final Map<String, Integer> indexMap = new LinkedHashMap<>();
 
+	public PoiExcelColumnIndex(PoiExcelSheetBean sheetBean) {
+		this.recordType = sheetBean.getRecordType();
+	}
+
 	public void initializeColumnIndex(PluginTask task, List<PoiExcelColumnBean> beanList) {
+		log.info("record_type={}", recordType);
+
 		int index = -1;
 		indexMap.clear();
 
 		Schema schema = task.getColumns().toSchema();
 		for (Column column : schema.getColumns()) {
 			PoiExcelColumnBean bean = beanList.get(column.getIndex());
-			PoiExcelColumnValueType valueType = bean.getValueType();
+			initializeCellAddress(column, bean);
 
-			if (valueType.useCell()) {
+			PoiExcelColumnValueType valueType = bean.getValueType();
+			if (valueType.useCell(recordType)) {
 				index = resolveColumnIndex(column, bean, index, valueType);
 				if (index < 0) {
 					index = 0;
 				}
 				bean.setColumnIndex(index);
 				indexMap.put(column.getName(), index);
-				if (log.isInfoEnabled()) {
-					String c = CellReference.convertNumToColString(index);
-					switch (valueType) {
-					default:
-						String suffix = bean.getValueTypeSuffix();
-						if (suffix != null) {
-							log.info("column.name={} <- cell_column={}, value_type={}, value=[{}]", column.getName(),
-									c, valueType, suffix);
-						} else {
-							log.info("column.name={} <- cell_column={}, value_type={}, value={}", column.getName(), c,
-									valueType, suffix);
-						}
-						break;
-					case CELL_VALUE:
-					case CELL_FORMULA:
-					case COLUMN_NUMBER:
-						log.info("column.name={} <- cell_column={}, value_type={}", column.getName(), c, valueType);
-						break;
-					}
-				}
-			} else {
-				if (log.isInfoEnabled()) {
-					switch (valueType) {
-					default:
-						String suffix = bean.getValueTypeSuffix();
-						if (suffix != null) {
-							log.info("column.name={} <- value_type={}, value=[{}]", column.getName(), valueType, suffix);
-						} else {
-							log.info("column.name={} <- value_type={}, value={}", column.getName(), valueType, suffix);
-						}
-						break;
-					case SHEET_NAME:
-					case ROW_NUMBER:
-						log.info("column.name={} <- value_type={}", column.getName(), valueType);
-						break;
-					}
-				}
 			}
+
+			initializeCellAddress2(column, bean, index);
+
+			if (log.isInfoEnabled()) {
+				logColumn(column, bean, valueType, index);
+			}
+		}
+	}
+
+	protected void initializeCellAddress(Column column, PoiExcelColumnBean bean) {
+		if (bean.getCellAddress() != null) {
+			return;
+		}
+
+		Optional<String> rowOption = bean.getRowNumber();
+		Optional<String> colOption = bean.getColumnNumber();
+		if (rowOption.isPresent() && colOption.isPresent()) {
+			String rowNumber = rowOption.get();
+			String colNumber = colOption.get();
+			initializeCellAddress(column, bean, rowNumber, colNumber);
+			return;
+		}
+
+		if (recordType == RecordType.SHEET) {
+			String rowNumber = rowOption.or("1");
+			String colNumber = colOption.or("A");
+			initializeCellAddress(column, bean, rowNumber, colNumber);
+			return;
+		}
+	}
+
+	protected void initializeCellAddress(Column column, PoiExcelColumnBean bean, String rowNumber, String columnNumber) {
+		int columnIndex = convertColumnIndex(column, OPTION_NAME_CELL_COLUMN, columnNumber);
+		int rowIndex = convertColumnIndex(column, OPTION_NAME_CELL_ROW, rowNumber);
+		CellReference ref = new CellReference(rowIndex, columnIndex);
+		bean.setCellAddress(ref);
+	}
+
+	protected void initializeCellAddress2(Column column, PoiExcelColumnBean bean, int index) {
+		if (bean.getCellAddress() != null) {
+			return;
+		}
+
+		Optional<String> recordOption = recordType.getRecordOption(bean);
+		if (recordOption.isPresent()) {
+			int rowIndex, columnIndex;
+			switch (recordType) {
+			case ROW:
+				rowIndex = convertColumnIndex(column, recordType.getRecordOptionName(), recordOption.get());
+				columnIndex = (index >= 0) ? index : 0;
+				break;
+			case COLUMN:
+				rowIndex = (index >= 0) ? index : 0;
+				columnIndex = convertColumnIndex(column, recordType.getRecordOptionName(), recordOption.get());
+				break;
+			default:
+				throw new IllegalStateException();
+			}
+			CellReference ref = new CellReference(rowIndex, columnIndex);
+			bean.setCellAddress(ref);
 		}
 	}
 
 	protected int resolveColumnIndex(Column column, PoiExcelColumnBean bean, int index,
 			PoiExcelColumnValueType valueType) {
-		Optional<String> numberOption = bean.getColumnNumber();
+		Optional<String> numberOption = recordType.getNumberOption(bean);
+		PoiExcelCellAddress cellAddress = bean.getCellAddress();
+
+		if (cellAddress != null) {
+			return index;
+		}
+
 		if (numberOption.isPresent()) {
 			String columnNumber = numberOption.get();
 			if (columnNumber.length() >= 1) {
@@ -96,7 +136,7 @@ public class PoiExcelColumnIndex {
 					break;
 				}
 			}
-			return convertColumnIndex(column, columnNumber);
+			return convertColumnIndex(column, recordType.getNumberOptionName(), columnNumber);
 		} else {
 			if (valueType.nextIndex()) {
 				index++;
@@ -167,11 +207,12 @@ public class PoiExcelColumnIndex {
 
 	protected void checkIndex(Column column, int index) {
 		if (index < 0) {
-			throw new RuntimeException(MessageFormat.format("column_number out of range at {0}", column));
+			throw new RuntimeException(MessageFormat.format("{0} out of range at {1}",
+					recordType.getNumberOptionName(), column));
 		}
 	}
 
-	protected int convertColumnIndex(Column column, String columnNumber) {
+	protected int convertColumnIndex(Column column, String numberOptionName, String columnNumber) {
 		int index;
 		try {
 			char c = columnNumber.charAt(0);
@@ -181,13 +222,92 @@ public class PoiExcelColumnIndex {
 				index = CellReference.convertColStringToIndex(columnNumber);
 			}
 		} catch (Exception e) {
-			throw new RuntimeException(MessageFormat.format("illegal column_number=\"{0}\" at {1}", columnNumber,
-					column), e);
+			throw new RuntimeException(MessageFormat.format("illegal {0}=\"{1}\" at {2}", numberOptionName,
+					columnNumber, column), e);
 		}
 		if (index < 0) {
-			throw new RuntimeException(MessageFormat.format("illegal column_number=\"{0}\" at {1}", columnNumber,
-					column));
+			throw new RuntimeException(MessageFormat.format("illegal {0}=\"{1}\" at {2}", numberOptionName,
+					columnNumber, column));
 		}
 		return index;
 	}
+
+	private static final String OPTION_NAME_CELL_COLUMN = ColumnOptionTask.CELL_COLUMN;
+	private static final String OPTION_NAME_CELL_ROW = ColumnOptionTask.CELL_ROW;
+
+	protected void logColumn(Column column, PoiExcelColumnBean bean, PoiExcelColumnValueType valueType, int index) {
+		PoiExcelCellAddress cellAddress = bean.getCellAddress();
+
+		String cname, cvalue;
+		if (cellAddress != null) {
+			cname = "cell_address";
+			cvalue = cellAddress.getString();
+		} else {
+			switch (recordType) {
+			default:
+				cname = OPTION_NAME_CELL_COLUMN;
+				cvalue = CellReference.convertNumToColString(index);
+				break;
+			case COLUMN:
+				cname = OPTION_NAME_CELL_ROW;
+				cvalue = Integer.toString(index + 1);
+				break;
+			case SHEET:
+				cname = "sheet";
+				cvalue = null;
+				break;
+			}
+		}
+
+		switch (valueType) {
+		default:
+		case CELL_VALUE:
+		case CELL_FORMULA:
+		case CELL_TYPE:
+		case CELL_CACHED_TYPE:
+			log.info("column.name={} <- {}={}, value={}", column.getName(), cname, cvalue, valueType);
+			break;
+		case CELL_STYLE:
+		case CELL_FONT:
+		case CELL_COMMENT:
+			String suffix = bean.getValueTypeSuffix();
+			if (suffix != null) {
+				log.info("column.name={} <- {}={}, value={}[{}]", column.getName(), cname, cvalue, valueType, suffix);
+			} else {
+				log.info("column.name={} <- {}={}, value={}", column.getName(), cname, cvalue, valueType);
+			}
+			break;
+
+		case SHEET_NAME:
+			if (cellAddress != null && cellAddress.getSheetName() != null) {
+				log.info("column.name={} <- {}={}, value={}", column.getName(), cname, cvalue, valueType);
+			} else {
+				log.info("column.name={} <- value={}", column.getName(), valueType);
+			}
+			break;
+		case ROW_NUMBER:
+			if (cellAddress != null || cname.equals(OPTION_NAME_CELL_ROW)) {
+				log.info("column.name={} <- {}={}, value={}", column.getName(), cname, cvalue, valueType);
+			} else {
+				log.info("column.name={} <- value={}", column.getName(), valueType);
+			}
+			break;
+		case COLUMN_NUMBER:
+			if (cellAddress != null || cname.equals(OPTION_NAME_CELL_COLUMN)) {
+				log.info("column.name={} <- {}={}, value={}", column.getName(), cname, cvalue, valueType);
+			} else {
+				log.info("column.name={} <- value={}", column.getName(), valueType);
+			}
+			break;
+
+		case CONSTANT:
+			String value = bean.getValueTypeSuffix();
+			if (value != null) {
+				log.info("column.name={} <- value={}[{}]", column.getName(), valueType, value);
+			} else {
+				log.info("column.name={} <- value={}({})", column.getName(), valueType, value);
+			}
+			break;
+		}
+	}
 }