• Home
• com.scudata.esproc
• esproc
• 20240731
• source code
• ColPhyTable.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

com.scudata.dw.ColPhyTable Maven / Gradle / Ivy

package com.scudata.dw;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;

import com.scudata.array.IArray;
import com.scudata.array.LongArray;
import com.scudata.common.IntArrayList;
import com.scudata.common.MessageManager;
import com.scudata.common.RQException;
import com.scudata.dm.BaseRecord;
import com.scudata.dm.Context;
import com.scudata.dm.DataStruct;
import com.scudata.dm.ObjectReader;
import com.scudata.dm.Record;
import com.scudata.dm.Sequence;
import com.scudata.dm.SerialBytes;
import com.scudata.dm.Table;
import com.scudata.dm.cursor.ConjxCursor;
import com.scudata.dm.cursor.ICursor;
import com.scudata.dm.cursor.MemoryCursor;
import com.scudata.dm.cursor.MergesCursor;
import com.scudata.dm.cursor.MultipathCursors;
import com.scudata.dm.cursor.UpdateIdCursor;
import com.scudata.expression.Constant;
import com.scudata.expression.Expression;
import com.scudata.expression.Node;
import com.scudata.expression.UnknownSymbol;
import com.scudata.expression.mfn.serial.Sbs;
import com.scudata.expression.operator.Add;
import com.scudata.expression.operator.DotOperator;
import com.scudata.expression.operator.Equals;
import com.scudata.expression.operator.Greater;
import com.scudata.expression.operator.NotEquals;
import com.scudata.expression.operator.NotGreater;
import com.scudata.expression.operator.NotSmaller;
import com.scudata.expression.operator.Smaller;
import com.scudata.resources.EngineMessage;
import com.scudata.thread.ThreadPool;
import com.scudata.util.Variant;

/**
 * ?д??????
 * @author runqian
 *
 */
public class ColPhyTable extends PhyTable {
	private transient ColumnMetaData []columns;
	private transient ColumnMetaData []allColumns; //??????
	private transient ColumnMetaData []sortedColumns; // ?????ֶ?
	private transient ColumnMetaData []allSortedColumns; // ?????ֶκ?????
	
	private transient String []allKeyColNames; // ?????ֶ??????飨????????
	
	private transient ColumnMetaData guideColumn;//????
	protected int sortedColStartIndex;//???????????ֶθ???
	
	private static final String GUIDE_COLNAME = "_guidecol";

	/**
	 * ???????л?
	 * @param groupTable
	 */
	public ColPhyTable(ComTable groupTable) {
		this.groupTable = groupTable;
		this.segmentBlockLink = new BlockLink(groupTable);
		this.modifyBlockLink1 = new BlockLink(groupTable);
		this.modifyBlockLink2 = new BlockLink(groupTable);
	}
	
	/**
	 * ???????л?
	 * @param groupTable
	 * @param parent
	 */
	public ColPhyTable(ComTable groupTable, ColPhyTable parent) {
		this.groupTable = groupTable;
		this.parent = parent;
		this.segmentBlockLink = new BlockLink(groupTable);
		this.modifyBlockLink1 = new BlockLink(groupTable);
		this.modifyBlockLink2 = new BlockLink(groupTable);
	}
	
	/**
	 * ?????´???һ??????
	 * @param groupTable
	 * @param colNames
	 * @param serialBytesLen
	 * @throws IOException
	 */
	public ColPhyTable(ComTable groupTable, String []colNames) throws IOException {
		this.groupTable = groupTable;
		this.tableName = "";
		this.segmentBlockLink = new BlockLink(groupTable);
		this.modifyBlockLink1 = new BlockLink(groupTable);
		this.modifyBlockLink2 = new BlockLink(groupTable);
		
		int count = colNames.length;
		columns = new ColumnMetaData[count];
		int keyStart = -1; // ????????ʼ?ֶ?
		
		// ??????ʼ?ֶ?ǰ????ֶ???Ϊ???????ֶ?
		for (int i = 0; i < count; ++i) {
			if (colNames[i].startsWith(KEY_PREFIX)) {
				keyStart = i;
				break;
			}
		}
		
		for (int i = 0; i < count; ++i) {
			if (colNames[i].startsWith(KEY_PREFIX)) {
				String colName = colNames[i].substring(KEY_PREFIX.length());
				columns[i] = new ColumnMetaData(this, colName, true, true);
			} else if (i < keyStart) {
				columns[i] = new ColumnMetaData(this, colNames[i], true, false);
			} else {
				columns[i] = new ColumnMetaData(this, colNames[i], false, false);
			}
		}
		
		init();
		
		if (sortedColumns == null) {
			hasPrimaryKey = false;
			isSorted = false;
		}
		
		tableList = new ArrayList();
		this.reserve[0] = 4;
	}

	/**
	 * ?????´???һ??????
	 * @param groupTable
	 * @param colNames
	 * @param serialBytesLen
	 * @throws IOException
	 */
	public ColPhyTable(ComTable groupTable, String []colNames, int []serialBytesLen) throws IOException {
		this.groupTable = groupTable;
		this.tableName = "";
		this.colNames = colNames;
		this.segmentBlockLink = new BlockLink(groupTable);
		this.modifyBlockLink1 = new BlockLink(groupTable);
		this.modifyBlockLink2 = new BlockLink(groupTable);
		
		int count = colNames.length;
		columns = new ColumnMetaData[count];
		for (int i = 0; i < count; ++i) {
			columns[i] = new ColumnMetaData(this, colNames[i], serialBytesLen[i]);
		}
		
		init();
		
		if (sortedColumns == null) {
			hasPrimaryKey = false;
			isSorted = false;
		}
		tableList = new ArrayList();
	}

	/**
	 * ?????Ĵ???
	 * @param groupTable Ҫ?????????????
	 * @param colNames ??????
	 * @param serialBytesLen ?źų???
	 * @param tableName ??????
	 * @param parent ????????
	 * @throws IOException
	 */
	public ColPhyTable(ComTable groupTable, String []colNames, int []serialBytesLen,
			String tableName, ColPhyTable parent) throws IOException {
		this.groupTable = groupTable;
		this.parent = parent;
		this.tableName = tableName;
		this.colNames = colNames;
		this.segmentBlockLink = new BlockLink(groupTable);
		this.modifyBlockLink1 = new BlockLink(groupTable);
		this.modifyBlockLink2 = new BlockLink(groupTable);
		
		int count = colNames.length;
		columns = new ColumnMetaData[count];
		for (int i = 0; i < count; ++i) {
			if (colNames[i].startsWith(KEY_PREFIX)) {
				String colName = colNames[i].substring(KEY_PREFIX.length());
				columns[i] = new ColumnMetaData(this, colName, true, true);
			} else {
				columns[i] = new ColumnMetaData(this, colNames[i], false, false);
			}
		}
		
		init();
		
		if (getAllSortedColumns() == null) {
			hasPrimaryKey = false;
			isSorted = false;
		}
		
		if (parent != null) {
			//Ŀǰ????ֻ????һ??
			if (parent.parent != null) {
				MessageManager mm = EngineMessage.get();
				throw new RQException(mm.getMessage("ds.dsNotMatch"));
			}
			
			PhyTable primaryTable = parent;
			String []primarySortedColNames = primaryTable.getSortedColNames();
			String []primaryColNames = primaryTable.getColNames();
			ArrayList collist = new ArrayList();
			for (String name : primaryColNames) {
				collist.add(name);
			}
			
			//?ֶβ??????????ֶ??ظ?
			for (int i = 0, len = colNames.length; i < len; i++) {
				if (collist.contains(colNames[i])) {
					MessageManager mm = EngineMessage.get();
					throw new RQException(colNames[i] + mm.getMessage("dw.fieldSameToPrimaryTable"));
				}
			}
			
			for (String name : primarySortedColNames) {
				collist.remove(name);
			}

			sortedColStartIndex = primarySortedColNames.length;
			guideColumn = new ColumnMetaData(this, tableName + GUIDE_COLNAME, false, false);
		}
		
		tableList = new ArrayList();
	}
	
	/**
	 * ????src????һ??ͬ???Ļ???
	 * @param groupTable Ҫ?????????????
	 * @param parent ????????
	 * @param src ?ṩ?ṹ??Դ????
	 * @throws IOException
	 */
	public ColPhyTable(ComTable groupTable, ColPhyTable parent, ColPhyTable src) throws IOException {
		this.groupTable = groupTable;
		this.parent = parent;
		
		System.arraycopy(src.reserve, 0, reserve, 0, reserve.length);
		segmentCol = src.segmentCol;
		segmentSerialLen = src.segmentSerialLen;
		tableName = src.tableName;
		colNames = src.colNames;
		this.segmentBlockLink = new BlockLink(groupTable);
		this.modifyBlockLink1 = new BlockLink(groupTable);
		this.modifyBlockLink2 = new BlockLink(groupTable);
		
		int count = colNames.length;
		columns = new ColumnMetaData[count];
		ColumnMetaData []srcCols = src.getColumns();
		for (int i = 0; i < count; ++i) {
			columns[i] = new ColumnMetaData(this, srcCols[i]);
		}
		
		init();
		
		if (sortedColumns == null && allSortedColumns == null) {
			hasPrimaryKey = false;
			isSorted = false;
		}
		
		if (parent != null) {
			guideColumn = new ColumnMetaData(this, tableName + GUIDE_COLNAME, false, false);
		}

		dupIndexAdnCuboid(src);
		
		tableList = new ArrayList();
		for (PhyTable srcSub : src.tableList) {
			tableList.add(new ColPhyTable(groupTable, this, (ColPhyTable)srcSub));
		}
	}

	/**
	 * ??ʼ??????ȡά???????Ȼ?????Ϣ
	 */
	protected void init() {
		ColumnMetaData []columns = this.columns;
		int dimCount = 0;
		int keyCount = 0;
		int j = 0;
		
		// ?????????飬?????ļ???ʱ????Ӱ?쵽????????????Ĵ???
		colNames = new String[columns.length];
		for (ColumnMetaData col : columns) {
			if (col.isDim()) {
				dimCount++;
			}
			
			if (col.isKey()) {
				keyCount++;
			}
			
			colNames[j++] = col.getColName();
		}
		
		if (keyCount > 0) {
			sortedColumns = new ColumnMetaData[dimCount];
			allKeyColNames = new String[keyCount];
			
			int i = 0, k = 0;
			for (ColumnMetaData col : columns) {
				if (col.isDim()) {
					sortedColumns[i++] = col;
				}
				
				if (col.isKey()) {
					allKeyColNames[k++] = col.getColName();
				}
			}
		}
		
		if (parent != null) {
			// ?ϲ???????????
			String []parentKeys = parent.getAllKeyColNames();
			if (keyCount > 0) {
				int parentKeyCount = parentKeys.length;
				String []tmp = new String[parentKeyCount+ keyCount ];
				System.arraycopy(parentKeys, 0, tmp, 0, parentKeyCount);
				System.arraycopy(allKeyColNames, 0, tmp, parentKeyCount, keyCount);
				allKeyColNames = tmp;
			} else {
				allKeyColNames = parentKeys;
			}
			
			String []primarySortedColNames = parent.getSortedColNames();
			sortedColStartIndex = primarySortedColNames.length;
			
			allSortedColumns = new ColumnMetaData[sortedColStartIndex + dimCount];
			ColumnMetaData []baseSortedCols = ((ColPhyTable) parent).getSortedColumns();
			int i = 0;
			if (baseSortedCols != null) {
				for (ColumnMetaData col : baseSortedCols) {
					allSortedColumns[i++] = col;
				}
			}
			if (sortedColumns != null) {
				for (ColumnMetaData col : sortedColumns) {
					allSortedColumns[i++] = col;
				}
			}
			ColumnMetaData []parentColumns = ((ColPhyTable) parent).getSortedColumns();
			allColumns = new ColumnMetaData[parentColumns.length + columns.length];
			allColNames = new String[parentColumns.length + columns.length];
			i = 0;
			for (ColumnMetaData col : parentColumns) {
				allColNames[i] = col.getColName();
				allColumns[i++] = col;
			}
			for (ColumnMetaData col : columns) {
				allColNames[i] = col.getColName();
				allColumns[i++] = col;
			}
			ds = new DataStruct(allColNames);
		} else {
			ds = new DataStruct(colNames);
		}
	}
	
	public ColumnMetaData[] getColumns() {
		return columns;
	}
	
	/**
	 * ?????????С?????????key?У?
	 * @return
	 */
	public ColumnMetaData[] getAllColumns() {
		if (parent == null) return columns;
		return allColumns;
	}
	
	/**
	 * ?????????С??????????????ֶ?)
	 * @return
	 */
	ColumnMetaData[] getTotalColumns() {
		if (parent == null) return columns;
		int baseColCount = ((ColPhyTable)parent).columns.length;
		int len = baseColCount + columns.length;
		ColumnMetaData[] cols = new ColumnMetaData[len];
		System.arraycopy(((ColPhyTable)parent).columns, 0, cols, 0, baseColCount);
		System.arraycopy(columns, 0, cols, baseColCount, columns.length);		
		return cols;
	}
	
	/**
	 * ?????????????ơ??????????????ֶ?)
	 * @return
	 */
	public String[] getTotalColNames() {
		if (parent == null) return colNames;
		int baseColCount = parent.colNames.length;
		int len = baseColCount + colNames.length;
		String[] names = new String[len];
		System.arraycopy(parent.colNames, 0, names, 0, baseColCount);
		System.arraycopy(colNames, 0, names, baseColCount, colNames.length);		
		return names;
	}
	
	/**
	 * ??????????
	 * @return
	 */
	public ColumnMetaData[] getSortedColumns() {
		return sortedColumns;
	}
	
	/**
	 * ?????????У???????)
	 * @return
	 */
	public ColumnMetaData[] getAllSortedColumns() {
		if (parent == null) return sortedColumns;
		return allSortedColumns;
	}
	
	/**
	 * ????????????
	 * @return
	 */
	public String[] getSortedColNames() {
		if (sortedColumns == null) return null;
		int len = sortedColumns.length;
		String []names = new String[len];
		for (int i = 0; i < len; ++i) {
			names[i] = sortedColumns[i].getColName();
		}
		return names;
	}

	/**
	 * ????????????????????)
	 * @return
	 */
	public String[] getAllSortedColNames() {
		if (parent == null) return getSortedColNames();
		if (allSortedColumns == null) return null;
		int len = allSortedColumns.length;
		String []names = new String[len];
		for (int i = 0; i < len; ++i) {
			names[i] = allSortedColumns[i].getColName();
		}
		return names;
	}
	
	/**
	 * ȡ?????ֶ?????????????
	 * @return ?????ֶ???????
	 */
	public String[] getAllKeyColNames() {
		return allKeyColNames;
	}
	
	/**
	 * ?????ֶ???????ָ????
	 * @param fields ?ֶ???
	 * @return
	 */
	public ColumnMetaData[] getColumns(String []fields) {
		if (fields == null) {
			return columns;
		}
		
		ColumnMetaData []columns = this.columns;
		int srcCount = columns.length;
		int count = fields.length;
		ColumnMetaData []result = new ColumnMetaData[count];
		
		Next:
		for (int i = 0; i < count; ++i) {
			String field = fields[i];
			for (int s = 0; s < srcCount; ++s) {
				if (columns[s].isColumn(field)) {
					result[i] = columns[s];
					continue Next;
				}
			}
			
			MessageManager mm = EngineMessage.get();
			throw new RQException(field + mm.getMessage("ds.fieldNotExist"));
		}
		
		return result;
	}
	
	/**
	 * ????ÿ???źŵij??ȣ???????ź??еĻ???
	 */
	public int[] getSerialBytesLen() {
		int len = columns.length;
		int []serialBytesLen = new int[len];
		for (int i = 0; i < len; i++) {
			serialBytesLen[i] = columns[i].getSerialBytesLen();
		}
		return serialBytesLen;
	}
	
	/**
	 * ??ȡexp???漰????
	 * @param exps
	 * @return
	 */
	public ColumnMetaData[] getColumns(Expression []exps) {
		if (exps == null) {
			return columns;
		}
		
		ColumnMetaData []columns = this.columns;
		int srcCount = columns.length;
		int count = exps.length;
		ColumnMetaData []result = new ColumnMetaData[count];

		Next:
		for (int i = 0; i < count; ++i) {
			if (exps[i].getHome() instanceof UnknownSymbol) {
				String col = exps[i].getIdentifierName();
				for (int s = 0; s < srcCount; ++s) {
					if (columns[s].isColumn(col)) {
						result[i] = columns[s];
						continue Next;
					}
				}

				MessageManager mm = EngineMessage.get();
				throw new RQException(col + mm.getMessage("ds.fieldNotExist"));
			}
		}
		return result;
	}
	
	/**
	 * ??ȡexp????Ҫ???????(k.sbs() k1+k2)
	 * @param exps
	 * @return
	 */
	public ArrayList getExpColumns(Expression []exps) {
		if (exps == null) {
			return null;
		}
		
		ArrayList result = new ArrayList();
		ColumnMetaData []columns = this.columns;
		int srcCount = columns.length;
		int count = exps.length;

		Next:
		for (int i = 0; i < count; ++i) {
			if (exps[i].getHome() instanceof DotOperator) {
				String col = null;
				Object left = exps[i].getHome().getLeft();
				Object right = exps[i].getHome().getRight();
				if (left instanceof UnknownSymbol && right instanceof Sbs) {
					col = ((UnknownSymbol)left).getName();
				} else {
					continue;
				}
				for (int s = 0; s < srcCount; ++s) {
					if (columns[s].isColumn(col)) {
						if (! result.contains(columns[s])) {
							result.add(columns[s]);
						}
						continue Next;
					}
				}

				MessageManager mm = EngineMessage.get();
				throw new RQException(col + mm.getMessage("ds.fieldNotExist"));
			} else if (exps[i].getHome() instanceof Add) {
				String col1 = null;
				String col2 = null;
				Object obj1 = exps[i].getHome().getLeft();
				Object obj2 = exps[i].getHome().getRight();
				if ((obj1 instanceof UnknownSymbol) 
						&& (obj2 instanceof UnknownSymbol)) {
					col1 = ((UnknownSymbol)obj1).getName();
					col2 = ((UnknownSymbol)obj2).getName();
				}
				boolean b1 = false,b2 = false;
				for (int s = 0; s < srcCount; ++s) {
					if (columns[s].isColumn(col1)) {
						if (! result.contains(columns[s])) {
							result.add(columns[s]);
						}
						b1 = true;
					}
					if (columns[s].isColumn(col2)) {
						if (! result.contains(columns[s])) {
							result.add(columns[s]);
						}
						b2 = true;
					}
				}
				if (b1 && b2) continue;
				MessageManager mm = EngineMessage.get();
				throw new RQException(col1 + " or " + col2 + mm.getMessage("ds.fieldNotExist"));
			}
		}
		if (result.size() == 0) {
			return null;
		}
		return result;
	}

	/**
	 * ?????ֶ????????
	 * @param field
	 * @return
	 */
	public ColumnMetaData getColumn(String field) {
		ColumnMetaData []columns = this.columns;
		for (ColumnMetaData col : columns) {
			if (col.isColumn(field)) {
				return col;
			}
		}
		
		return null;
	}

	/**
	 * ???ظ????ĵ???
	 * @return
	 */
	public ColumnMetaData getGuideColumn() {
		return guideColumn;
	}
	
	/**
	 * ?????һ??ռ?
	 */
	protected void applyFirstBlock() throws IOException {
		if (segmentBlockLink.isEmpty()) {
			segmentBlockLink.setFirstBlockPos(groupTable.applyNewBlock());
			ColumnMetaData []columns = this.columns;
			for (ColumnMetaData col : columns) {
				col.applySegmentFirstBlock();
			}
			
			for (ColumnMetaData col : columns) {
				col.applyDataFirstBlock();
			}
			
			if (parent != null) {
				guideColumn.applySegmentFirstBlock();
				guideColumn.applyDataFirstBlock();
			}
		}
	}
	
	/**
	 * ׼??д????׷?ӡ?ɾ?????޸?????ǰ???á?
	 * ???ú??Թؼ???Ϣ???б??ݣ???ֹдһ???????ʱ????????
	 */
	protected void prepareAppend() throws IOException {
		applyFirstBlock();
		
		segmentWriter = new BlockLinkWriter(segmentBlockLink, true);
		for (ColumnMetaData col : columns) {
			col.prepareWrite();
		}
		if (parent != null) {
			guideColumn.prepareWrite();
		}
	}
	
	/**
	 * ????д
	 */
	protected void finishAppend() throws IOException {
		segmentWriter.finishWrite();
		segmentWriter = null;
		for (ColumnMetaData col : columns) {
			col.finishWrite();
		}
		
		if (parent != null) {
			guideColumn.finishWrite();
		}
		
		groupTable.save();
		updateIndex();
	}
	
	/**
	 * ??ȡ??ͷ????
	 */
	public void readExternal(BufferReader reader) throws IOException {
		reader.read(reserve);
		tableName = reader.readUTF();
		colNames = reader.readStrings();
		dataBlockCount = reader.readInt32();
		totalRecordCount = reader.readLong40();
		segmentBlockLink.readExternal(reader);
		curModifyBlock = reader.readByte();
		modifyBlockLink1.readExternal(reader);
		modifyBlockLink2.readExternal(reader);
		
		int count = reader.readInt();
		columns = new ColumnMetaData[count];
		for (int i = 0; i < count; ++i) {
			columns[i] = new ColumnMetaData(this);
			columns[i].readExternal(reader, reserve[0]);
		}
		
		count = reader.readInt();
		if (count > 0) {
			maxValues = new Object[count];
			for (int i = 0; i < count; ++i) {
				maxValues[i] = reader.readObject();
			}
		}
	
		hasPrimaryKey = reader.readBoolean();
		isSorted = reader.readBoolean();
		boolean isPrimaryTable  = reader.readBoolean();
		if (!isPrimaryTable) {
			guideColumn = new ColumnMetaData(this);
			guideColumn.readExternal(reader, reserve[0]);
		}
		
		indexNames = reader.readStrings();
		if (indexNames == null) {
			indexFields = null;
			indexValueFields = null;
		} else {
			int indexCount = indexNames.length;
			indexFields = new String[indexCount][];
			for (int i = 0; i < indexCount; i++) {
				indexFields[i] = reader.readStrings();
			}
			indexValueFields = new String[indexCount][];
			for (int i = 0; i < indexCount; i++) {
				indexValueFields[i] = reader.readStrings();
			}
		}

		if (groupTable.reserve[0] > 2) {
			cuboids = reader.readStrings();//?汾3????
		}
		segmentCol = (String)reader.readObject();
		segmentSerialLen = reader.readInt();
		init();
		
		count = reader.readInt();
		tableList = new ArrayList(count);
		for (int i = 0; i < count; ++i) {
			PhyTable table = new ColPhyTable(groupTable, this);
			table.readExternal(reader);
			tableList.add(table);
		}
	}
	
	/**
	 * д????ͷ????
	 */
	public void writeExternal(BufferWriter writer) throws IOException {
		reserve[0] = 5;
		writer.write(reserve);
		writer.writeUTF(tableName);
		writer.writeStrings(colNames);
		writer.writeInt32(dataBlockCount);
		writer.writeLong40(totalRecordCount);
		segmentBlockLink.writeExternal(writer);
		writer.writeByte(curModifyBlock);
		modifyBlockLink1.writeExternal(writer);
		modifyBlockLink2.writeExternal(writer);
		
		ColumnMetaData []columns = this.columns;
		int count = columns.length;
		writer.writeInt(count);
		for (int i = 0; i < count; ++i) {
			columns[i].writeExternal(writer);
		}
		
		if (maxValues == null) {
			writer.writeInt(0);
		} else {
			writer.writeInt(maxValues.length);
			for (Object val : maxValues) {
				writer.writeObject(val);
			}
			
			writer.flush();
		}
		
		writer.writeBoolean(hasPrimaryKey);
		writer.writeBoolean(isSorted);
		writer.writeBoolean(parent == null);
		if (parent != null) {
			guideColumn.writeExternal(writer);
		}
		
		writer.writeStrings(indexNames);
		if (indexNames != null) {
			for (int i = 0, indexCount = indexNames.length; i < indexCount; i++) {
				writer.writeStrings(indexFields[i]);
			}
			for (int i = 0, indexCount = indexNames.length; i < indexCount; i++) {
				writer.writeStrings(indexValueFields[i]);
			}
		}

		writer.writeStrings(cuboids);//?汾3????
		
		writer.writeObject(segmentCol);
		writer.flush();
		writer.writeInt(segmentSerialLen);
		
		ArrayList tableList = this.tableList;
		count = tableList.size();
		writer.writeInt(count);
		for (int i = 0; i < count; ++i) {
			tableList.get(i).writeExternal(writer);
		}
	}
	
	/**
	 * ׷?Ӹ?????һ??????
	 * @param data
	 * @param start ??ʼ????
	 * @param recList ????????
	 * @throws IOException
	 */
	private void appendAttachedDataBlock(Sequence data, boolean []isMyCol, LongArray recList) throws IOException {
		ColumnMetaData []columns = this.allColumns;
		int count = columns.length;

		Object []minValues = new Object[count];;//һ?????Сάֵ
		Object []maxValues = new Object[count];;//һ??????άֵ
		Object []startValues = new Object[count];
		int[] dataTypeInfo = new int[count];
				
		BufferWriter bufferWriter = guideColumn.getColDataBufferWriter();
		BufferWriter bufferWriters[] = new BufferWriter[count];
		
		DataBlockWriterJob[] jobs = new DataBlockWriterJob[count];
		ThreadPool pool = ThreadPool.newInstance(count);
		
		int end = data.length();
		try {
			//д????
			bufferWriter.write(DataBlockType.LONG);
			for (int i = 1; i <= end; ++i) {
				bufferWriter.writeLong(recList.getLong(i));
			}
			bufferWriter.writeBoolean(false);
			
			//д??????????
			for (int i = 0; i < count; i++) {
				if (!isMyCol[i])
					continue;
				bufferWriters[i] = columns[i].getColDataBufferWriter();
				Sequence dict = columns[i].getDict();
				jobs[i] = new DataBlockWriterJob(bufferWriters[i], data, dict, i, 1, end, 
						maxValues, minValues, startValues, dataTypeInfo);
				pool.submit(jobs[i]);
			}
			
			for (int i = 0; i < count; ++i) {
				if (!isMyCol[i]) continue;
				jobs[i].join();
			}
		} finally {
			pool.shutdown();
		}
		
		//ͳ????????????
		boolean doCheck = groupTable.isCheckDataPure();
		for (int j = 0; j < count; j++) {
			if (!isMyCol[j]) continue;
			columns[j].adjustDataType(dataTypeInfo[j], doCheck);
			columns[j].initDictArray();
		}

		if (recList.size() == 0) {
			//????ǿտ飬?????дһ??null
			bufferWriter.writeObject(null);
			for (int j = 0; j < count; j++) {
				if (!isMyCol[j]) continue;
				bufferWriters[j].writeObject(null);
			}
		}
		
		guideColumn.appendColBlock(bufferWriter.finish());

		//?ύÿ???п?buffer
		for (int j = 0; j < count; j++) {
			if (!isMyCol[j]) continue;
			columns[j].appendColBlock(bufferWriters[j].finish(), minValues[j], maxValues[j], startValues[j]);
		}
		
		//???·ֶ???Ϣbuffer
		appendSegmentBlock(end);
	}
	
	/**
	 * ׷?Ӹ?????һ??????(?ɸ?ʽ)
	 * @param data
	 * @param start ??ʼ????
	 * @param recList ????????
	 * @throws IOException
	 */
	public void appendAttachedDataBlockV3(Sequence data, boolean []isMyCol, LongArray recList) throws IOException {
		BaseRecord r;
		ColumnMetaData []columns = this.allColumns;
		int count = columns.length;
		int []serialBytesLen = new int[count];
		Object []minValues = null;//һ?????Сάֵ
		Object []maxValues = null;//һ??????άֵ
		Object []startValues = null;
		
		if (sortedColumns != null) {
			minValues = new Object[count];
			maxValues = new Object[count];
			startValues = new Object[count];
		}
		
		BufferWriter bufferWriter = guideColumn.getColDataBufferWriter();
		BufferWriter bufferWriters[] = new BufferWriter[count];
		for (int i = 0; i < count; i++) {
			if (!isMyCol[i]) continue;
			serialBytesLen[i] = columns[i].getSerialBytesLen();
			bufferWriters[i] = columns[i].getColDataBufferWriter();
		}
		
		int end = data.length();
		for (int i = 1; i <= end; ++i) {
			//д????
			bufferWriter.writeObject(recList.get(i - 1));
			
			r = (BaseRecord) data.get(i);
			Object[] vals = r.getFieldValues();
			//??һ??д?????е?buffer
			for (int j = 0; j < count; j++) {
				if (!isMyCol[j]) continue;
				Object obj = vals[j];
				if (serialBytesLen[j] > 0) {
					if (obj instanceof SerialBytes) {
						bufferWriters[j].writeObject(obj);
					} else {
						Long val;
						if (obj instanceof Integer) {
							val = (Integer)obj & 0xFFFFFFFFL;
						} else {
							val = (Long) obj;
						}
						bufferWriters[j].writeObject(new SerialBytes(val, serialBytesLen[j]));
					}
				} else {
					bufferWriters[j].writeObject(obj);
				}
			}
			for (int j = 0; j < count; j++) {
				if (!isMyCol[j]) continue;
				Object obj = vals[j];
				if (columns[j].isDim()) {
					if (Variant.compare(obj, maxValues[j], true) > 0)
						maxValues[j] = obj;
					if (i == 1)
					{
						minValues[j] = obj;//??һ??Ҫ??ֵ????Ϊnull??ʾ??С
						startValues[j] = obj;
					}
					if (Variant.compare(obj, minValues[j], true) < 0)
						minValues[j] = obj;
				}
			}
		}

		if (recList.size() == 0) {
			//????ǿտ飬?????дһ??null
			bufferWriter.writeObject(null);
			for (int j = 0; j < count; j++) {
				if (!isMyCol[j]) continue;
				bufferWriters[j].writeObject(null);
			}
		}
		
		guideColumn.appendColBlock(bufferWriter.finish());
		
		if (sortedColumns == null) {
			//?ύÿ???п?buffer
			for (int j = 0; j < count; j++) {
				if (!isMyCol[j]) continue;
				columns[j].appendColBlock(bufferWriters[j].finish());
			}
			//???·ֶ???Ϣbuffer
			appendSegmentBlock(end);
			return;
		}

		//?ύÿ???п?buffer
		for (int j = 0; j < count; j++) {
			if (!isMyCol[j]) continue;
			if (!columns[j].isDim()) {
				//׷???п?
				columns[j].appendColBlock(bufferWriters[j].finish());
			} else {
				//׷??ά??
				columns[j].appendColBlock(bufferWriters[j].finish(), minValues[j], maxValues[j], startValues[j]);
			}
		}
		
		//???·ֶ???Ϣbuffer
		appendSegmentBlock(end);
	}
	
	/**
	 * ??data???е?ָ????Χ??????д??(?¸?ʽ)
	 * @param data ????????
	 * @param start ??ʼλ??
	 * @param end ????λ??
	 * @throws IOException
	 */
	private void appendDataBlock(Sequence data, int start, int end) throws IOException {
		ColumnMetaData []columns = this.columns;
		int count = columns.length;
		Object []minValues = new Object[count];//һ?????Сάֵ
		Object []maxValues = new Object[count];//һ??????άֵ
		Object []startValues = new Object[count];
		int[] dataTypeInfo = new int[count];

		BufferWriter bufferWriters[] = new BufferWriter[count];
		DataBlockWriterJob[] jobs = new DataBlockWriterJob[count];
		ThreadPool pool = ThreadPool.newInstance(count);
		
		try {
			for (int i = 0; i < count; i++) {
				bufferWriters[i] = columns[i].getColDataBufferWriter();
				Sequence dict = columns[i].getDict();
				jobs[i] = new DataBlockWriterJob(bufferWriters[i], data, dict, i, start, end, 
						maxValues, minValues, startValues, dataTypeInfo);
				pool.submit(jobs[i]);
			}
			
			for (int i = 0; i < count; ++i) {
				jobs[i].join();
			}
		} finally {
			pool.shutdown();
		}
		
		//ͳ????????????
		boolean doCheck = groupTable.isCheckDataPure();
		for (int j = 0; j < count; j++) {
			columns[j].adjustDataType(dataTypeInfo[j], doCheck);
			columns[j].initDictArray();
		}
		
		//?ύÿ???п?buffer
		for (int j = 0; j < count; j++) {
			columns[j].appendColBlock(bufferWriters[j].finish(), minValues[j], maxValues[j], startValues[j]);
		}
		
		//???·ֶ???Ϣbuffer
		appendSegmentBlock(end - start + 1);
	}
	
	/**
	 * ??data???е?ָ????Χ??????д??(?ɸ?ʽ)
	 * @param data ????????
	 * @param start ??ʼλ??
	 * @param end ????λ??
	 * @throws IOException
	 */
	public void appendDataBlockV3(Sequence data, int start, int end) throws IOException {
		BaseRecord r;
		ColumnMetaData []columns = this.columns;
		int count = columns.length;
		int []serialBytesLen = new int[count];
		Object []minValues = null;//һ?????Сάֵ
		Object []maxValues = null;//һ??????άֵ
		Object []startValues = null;
		
		if (sortedColumns != null) {
			minValues = new Object[count];
			maxValues = new Object[count];
			startValues = new Object[count];
		}
		
		BufferWriter bufferWriters[] = new BufferWriter[count];
		for (int i = 0; i < count; i++) {
			serialBytesLen[i] = columns[i].getSerialBytesLen();
			bufferWriters[i] = columns[i].getColDataBufferWriter();
		}
		
		IArray mems = data.getMems();
		for (int i = start; i <= end; ++i) {
			r = (BaseRecord) mems.get(i);
			mems.set(i, null);
			
			Object[] vals = r.getFieldValues();
			//??һ??д?????е?buffer
			for (int j = 0; j < count; j++) {
				Object obj = vals[j];
				if (serialBytesLen[j] > 0) {
					if (obj instanceof SerialBytes) {
						if (((SerialBytes)obj).length() > serialBytesLen[j]) {
							MessageManager mm = EngineMessage.get();
							throw new RQException(mm.getMessage("engine.indexOutofBound"));
						}
						bufferWriters[j].writeObject(obj);
					} else {
						MessageManager mm = EngineMessage.get();
						throw new RQException(mm.getMessage("dw.needSerialBytes"));
					}
				} else {
					bufferWriters[j].writeObject(obj);
				}
				if (columns[j].isDim()) {
					if (Variant.compare(obj, maxValues[j], true) > 0)
						maxValues[j] = obj;
					if (i == start) {
						minValues[j] = obj;//??һ??Ҫ??ֵ????Ϊnull??ʾ??С
						startValues[j] = obj;
					}
					if (Variant.compare(obj, minValues[j], true) < 0)
						minValues[j] = obj;
				}
			}
		}
		
		if (sortedColumns == null) {
			//?ύÿ???п?buffer
			for (int j = 0; j < count; j++) {
				columns[j].appendColBlock(bufferWriters[j].finish());
			}
			//???·ֶ???Ϣbuffer
			appendSegmentBlock(end - start + 1);
			return;
		}

		//?ύÿ???п?buffer
		for (int j = 0; j < count; j++) {
			if (!columns[j].isDim()) {
				//׷???п?
				columns[j].appendColBlock(bufferWriters[j].finish());
			} else {
				//׷??ά??
				columns[j].appendColBlock(bufferWriters[j].finish(), minValues[j], maxValues[j], startValues[j]);
			}
		}
		
		//???·ֶ???Ϣbuffer
		appendSegmentBlock(end - start + 1);
	}
	
	/**
	 * ???α??????д??
	 * @param cursor
	 * @throws IOException
	 */
	private void appendNormal(ICursor cursor) throws IOException {
		Sequence data = cursor.fetch(MIN_BLOCK_RECORD_COUNT);
		while (data != null && data.length() > 0) {
			appendDataBlock(data, 1, data.length());
			data = cursor.fetch(MIN_BLOCK_RECORD_COUNT);
		}
	}
	
	/**
	 * ???α??????д?? ????????
	 * @param cursor
	 * @throws IOException
	 */
	private void appendAttached(ICursor cursor) throws IOException {
		PhyTable primaryTable = parent;
		int pBlockCount = primaryTable.getDataBlockCount();//???????????ܿ???
		int curBlockCount = dataBlockCount;//Ҫ׷?ӵĿ?ʼ???
		int pkeyEndIndex = sortedColStartIndex;
		
		String []primaryTableKeys = primaryTable.getSortedColNames();
		ArrayList primaryTableKeyList = new ArrayList();
		for (String name : primaryTableKeys) {
			primaryTableKeyList.add(name);
		}
		String []colNames = getAllColNames();
		int fcount = colNames.length;
		boolean []isMyCol = new boolean[fcount];
		for (int i = 0; i < fcount; i++) {
			if (primaryTableKeyList.contains(colNames[i])) {
				isMyCol[i] = false;
			} else {
				isMyCol[i] = true;
			}
		}
		
		Cursor cs;
		if (primaryTable.totalRecordCount == 0) {
			MessageManager mm = EngineMessage.get();
			throw new RQException(mm.getMessage("dw.baseTableNull"));
		}
		cs = (Cursor) primaryTable.cursor(primaryTableKeys);
		cs.setSegment(curBlockCount, curBlockCount + 1);
		Sequence pkeyData = cs.fetch(ICursor.MAXSIZE);
		int pkeyIndex = 1;
		int pkeyDataLen = pkeyData.length();
		ComTableRecord curPkey = (ComTableRecord) pkeyData.get(1);
		Object []curPkeyVals = curPkey.getFieldValues();
		
		int sortedColCount = allSortedColumns.length;
		Object []tableMaxValues = this.maxValues;
		Object []lastValues = new Object[sortedColCount];//??һ??ά??ֵ
		
		LongArray guideCol = new LongArray(MIN_BLOCK_RECORD_COUNT);
		Sequence seq = new Sequence(MIN_BLOCK_RECORD_COUNT);
		Sequence data = cursor.fetch(ICursor.FETCHCOUNT);
		BaseRecord r;
		Object []vals = new Object[sortedColCount];
		int []findex = getSortedColIndex();
		
		while (data != null && data.length() > 0) {
			int len = data.length();
			for (int i = 1; i <= len; ++i) {
				r = (BaseRecord) data.get(i);
				for (int f = 0; f < sortedColCount; ++f) {
					vals[f] = r.getNormalFieldValue(findex[f]);
				}
				
				//?ұ???????????Ӧ?ļ?¼
				while (true) {
					int cmp = Variant.compareArrays(curPkeyVals, vals, pkeyEndIndex);
					if (cmp == 0) {
						break;
					} else if (cmp < 0) {
						pkeyIndex++;
						if (pkeyIndex > pkeyDataLen) {
							//ע?⣺??ʱ?п???seq??û?м?¼?????Ҫ׷??һ???տ?
							//??????һ???˾??ύһ??
							appendAttachedDataBlock(seq, isMyCol, guideCol);
							seq.clear();
							guideCol = new LongArray(MIN_BLOCK_RECORD_COUNT);
							
							//ȡ??һ??????????
							curBlockCount++;
							if (curBlockCount >= pBlockCount) {
								//????ȡ??????ˣ??????ﲻӦ?û??????ݣ????쳣
								MessageManager mm = EngineMessage.get();
								throw new RQException(mm.getMessage("dw.appendNotMatch") + r.toString(null));
							}
							cs = (Cursor) primaryTable.cursor(primaryTableKeys);
							cs.setSegment(curBlockCount, curBlockCount + 1);
							pkeyData = cs.fetch(ICursor.MAXSIZE);
							pkeyIndex = 1;
							pkeyDataLen = pkeyData.length();
						}
						curPkey = (ComTableRecord) pkeyData.get(pkeyIndex);
						curPkeyVals = curPkey.getFieldValues();
					} else if (cmp > 0) {
						//û?ҵ???Ӧ????????¼?????쳣
						MessageManager mm = EngineMessage.get();
						throw new RQException(mm.getMessage("dw.appendNotMatch") + r.toString(null));
					}
				}
				
				//?????????ȷ??Ҫ׷??һ????
				guideCol.add(curPkey.getRecordSeq());//???ӵ???
				
				//??????????????
				if (isSorted) {
					if (tableMaxValues != null) {
						int cmp = Variant.compareArrays(vals, tableMaxValues, sortedColCount);
						if (cmp < 0) {
							//????׷?ӵ????ݱ???????
							MessageManager mm = EngineMessage.get();
							throw new RQException(mm.getMessage("dw.appendAttachedTable"));
						} else if (cmp == 0){
							if (hasPrimaryKey) hasPrimaryKey = false;
						} else {
							System.arraycopy(vals, 0, tableMaxValues, 0, sortedColCount);
						}
					} else {
						tableMaxValues = maxValues = new Object[sortedColCount];
						System.arraycopy(vals, 0, tableMaxValues, 0, sortedColCount);
					}
				}
				
				seq.add(r);//???????ݴ?				
				System.arraycopy(vals, 0, lastValues, 0, sortedColCount);//????һ??άֵ				
			}
			data = cursor.fetch(ICursor.FETCHCOUNT);
		}
		
		//???????һ???п? (??????ȡ??????ˣ??????ﻹ?еĻ????Ͳ?????)
		if (seq.length() > 0) {
			appendAttachedDataBlock(seq, isMyCol, guideCol);
		}
		
	}
	
	/**
	 * ???α??????д????д??ʱ??Ҫ???зֶΡ?
	 * @param cursor
	 * @throws IOException
	 */
	private void appendSegment(ICursor cursor) throws IOException {
		int recCount = 0;
		int sortedColCount = sortedColumns.length;
		Object []tableMaxValues = this.maxValues;

		String segmentCol = getSegmentCol();
		int segmentSerialLen = getSegmentSerialLen();
		int segmentIndex = 0;

		for (int i = 0; i < sortedColCount; i++) {
			if (segmentCol.equals(sortedColumns[i].getColName())) {
				segmentIndex = i;
				break;
			}
		}
		int cmpLen = segmentIndex + 1;
		int serialBytesLen = sortedColumns[segmentIndex].getSerialBytesLen();
		if (segmentSerialLen == 0 || segmentSerialLen > serialBytesLen) {
			segmentSerialLen = serialBytesLen;
		}
		Object []lastValues = new Object[cmpLen];//??һ??ά??ֵ
		Object []curValues = new Object[cmpLen];//??ǰ??ά??ֵ
		
		Sequence seq = new Sequence(MIN_BLOCK_RECORD_COUNT);
		Sequence data = cursor.fetch(ICursor.FETCHCOUNT);
		BaseRecord r;
		Object []vals = new Object[sortedColCount];
		int []findex = getSortedColIndex();
		
		while (data != null && data.length() > 0) {
			int len = data.length();
			for (int i = 1; i <= len; ++i) {
				r = (BaseRecord) data.get(i);
				for (int f = 0; f < sortedColCount; ++f) {
					vals[f] = r.getNormalFieldValue(findex[f]);
				}

				//?????ж??Ƿ?һ???п???
				if (recCount >= MIN_BLOCK_RECORD_COUNT){
					System.arraycopy(vals, 0, curValues, 0, cmpLen);
					if (0 != Variant.compareArrays(lastValues, curValues, cmpLen)) {
						appendDataBlock(seq, 1, seq.length());
						seq.clear();
						recCount = 0;
					}
				}
				
				//??????????????
				if (isSorted) {
					if (tableMaxValues != null) {
						int cmp = Variant.compareArrays(vals, tableMaxValues, sortedColCount);
						if (cmp < 0) {
							//hasPrimaryKey = false;//???ٴ???????
							isSorted = false;
							maxValues = null;
						} else if (cmp == 0){
							//if (hasPrimaryKey) hasPrimaryKey = false;//???ٴ???????
						} else {
							System.arraycopy(vals, 0, tableMaxValues, 0, sortedColCount);
						}
					} else {
						tableMaxValues = maxValues = new Object[sortedColCount];
						System.arraycopy(vals, 0, tableMaxValues, 0, sortedColCount);
					}
					if (tableList.size() > 0 && !hasPrimaryKey) {
						//???ڸ???ʱ??????׷?ӵ????ݱ???????Ψһ
						MessageManager mm = EngineMessage.get();
						throw new RQException(mm.getMessage("dw.appendPrimaryTable"));
					}
				}
				
				seq.add(r);//???????ݴ?
				System.arraycopy(vals, 0, lastValues, 0, cmpLen);
				recCount++;
			}
			data = cursor.fetch(ICursor.FETCHCOUNT);
		}
		
		//???????һ???п?
		if (seq.length() > 0) {
			appendDataBlock(seq, 1, seq.length());
		}
		
	}
	
	/**
	 * ???α??????д????д??ʱ??Ҫ?ж??????Ƿ??ά????
	 * @param cursor
	 * @throws IOException
	 */
	private void appendSorted(ICursor cursor) throws IOException {
		int recCount = 0;
		int sortedColCount = sortedColumns.length;
		Object []tableMaxValues = this.maxValues;
		Object []lastValues = new Object[sortedColCount];//??һ??ά??ֵ
		
		Sequence seq = new Sequence(MIN_BLOCK_RECORD_COUNT);
		Sequence data = cursor.fetch(ICursor.FETCHCOUNT);
		BaseRecord r;
		Object []vals = new Object[sortedColCount];
		int []findex = getSortedColIndex();

		while (data != null && data.length() > 0) {
			int len = data.length();
			for (int i = 1; i <= len; ++i) {
				r = (BaseRecord) data.get(i);
				for (int f = 0; f < sortedColCount; ++f) {
					vals[f] = r.getNormalFieldValue(findex[f]);
				}

				//?????ж??Ƿ?һ???п???
				if (recCount >= MAX_BLOCK_RECORD_COUNT) {
					//??ʱ?ύһ??
					appendDataBlock(seq, 1, MAX_BLOCK_RECORD_COUNT/2);
					seq = (Sequence) seq.get(MAX_BLOCK_RECORD_COUNT/2 + 1, seq.length() + 1);
					recCount = seq.length(); 
				} else if (recCount >= MIN_BLOCK_RECORD_COUNT){
					boolean doAppend = false;
					if (0 != Variant.compareArrays(lastValues, vals, sortedColCount)) {
						doAppend = true;
					}
					if (doAppend) {
						appendDataBlock(seq, 1, seq.length());
						seq.clear();
						recCount = 0;
					}
				}
				
				//??????????????
				if (isSorted) {
					if (tableMaxValues != null) {
						int cmp = Variant.compareArrays(vals, tableMaxValues, sortedColCount);
						if (cmp < 0) {
							hasPrimaryKey = false;
							isSorted = false;
							maxValues = null;
						} else if (cmp == 0){
							if (hasPrimaryKey) {
								hasPrimaryKey = false;
							}
						} else {
							System.arraycopy(vals, 0, tableMaxValues, 0, sortedColCount);
						}
						if (tableList.size() > 0 && !hasPrimaryKey) {
							//???ڸ???ʱ??????׷?ӵ????ݱ???????Ψһ
							MessageManager mm = EngineMessage.get();
							throw new RQException(mm.getMessage("dw.appendPrimaryTable"));
						}
					} else {
						tableMaxValues = maxValues = new Object[sortedColCount];
						System.arraycopy(vals, 0, tableMaxValues, 0, sortedColCount);
					}
				}
				
				seq.add(r);//???????ݴ?				
				System.arraycopy(vals, 0, lastValues, 0, sortedColCount);//????һ??άֵ				
				recCount++;
			}
			data = cursor.fetch(ICursor.FETCHCOUNT);
		}
		
		//???????һ???п?
		if (seq.length() > 0) {
			appendDataBlock(seq, 1, seq.length());
		}
		
	}
	
	private void mergeAppend(ICursor cursor, String opt) throws IOException {
		// ??֧?ִ???????????鲢׷??
		if (!isSingleTable()) {
			throw new RQException("'append@m' is unimplemented in annex table!");
		}
		
		// ??????ݽṹ?Ƿ????
		Sequence data = cursor.peek(ICursor.FETCHCOUNT);		
		if (data == null || data.length() <= 0) {
			return;
		}
		
		//?жϽṹƥ??
		DataStruct ds = data.dataStruct();
		if (ds == null) {
			MessageManager mm = EngineMessage.get();
			throw new RQException(mm.getMessage("engine.needPurePmt"));
		}
		
		ColumnMetaData []columns = this.columns;
		int colCount = columns.length;
		if (colCount != ds.getFieldCount()) {
			MessageManager mm = EngineMessage.get();
			throw new RQException(mm.getMessage("engine.dsNotMatch"));
		}
		
		for (int i = 0; i < colCount; i++) {
			if (!ds.getFieldName(i).equals(columns[i].getColName())) {
				MessageManager mm = EngineMessage.get();
				throw new RQException(mm.getMessage("engine.dsNotMatch"));
			}
		}
		
		// ?鲢?????????ȱ??浽??ʱ?ļ?
		ColComTable groupTable = (ColComTable)getGroupTable();
		File srcFile = groupTable.getFile();
		File tmpFile = File.createTempFile("tmpdata", "", srcFile.getParentFile());
		ColComTable tmpGroupTable = null;
		
		try {
			Context ctx = new Context();
			tmpGroupTable = new ColComTable(tmpFile, groupTable);
			
			PhyTable baseTable = tmpGroupTable.getBaseTable();
			
			int dcount = sortedColumns.length;
			Expression []mergeExps = new Expression[dcount];
			for (int i = 0; i < dcount; ++i) {
				mergeExps[i] = new Expression(sortedColumns[i].getColName());
			}
			
			// ???鲢
			Cursor srcCursor = new Cursor(this);
			ICursor []cursors = new ICursor[]{srcCursor, cursor};
			MergesCursor mergeCursor = new MergesCursor(cursors, mergeExps, ctx);
			String[] indexNames = baseTable.indexNames;
			String[] cuboids = baseTable.cuboids;
			baseTable.deleteIndex(null);//??ʱ?ļ?????Ҫ??appendʱ????index??cuboid
			baseTable.deleteCuboid(null);
			baseTable.append(mergeCursor);
			baseTable.appendCache();
			baseTable.indexNames = indexNames;
			baseTable.cuboids = cuboids;
			tmpGroupTable.save();
			baseTable.close();
			
			// ?رղ?ɾ??????ļ???????ʱ?ļ???????Ϊ????ļ???
			groupTable.raf.close();
			if (groupTable.file.delete()) {
				tmpFile.renameTo(groupTable.file);
			} else {
				tmpFile.delete();
				MessageManager mm = EngineMessage.get();
				throw new RQException(mm.getMessage("dw.needCloseTable"));
			}
			
			// ???´????
			groupTable.reopen();
			groupTable.baseTable.resetIndex(ctx);
			groupTable.baseTable.resetCuboid(ctx);
		} finally {
			if (tmpGroupTable != null) {
				tmpGroupTable.raf.close();
			}
		}
	}
	
	/**
	 * ?Թ鲢??ʽ׷??(?ݲ?֧???и????????)
	 */
	public void append(ICursor cursor, String opt) throws IOException {
		if (opt != null && opt.indexOf('w') != -1) {
			int []keys = getDataStruct().getPKIndex();
			int deleteField = this.getDeleteFieldIndex(null, null);
			cursor = new UpdateIdCursor(cursor, keys, deleteField);
		}
		
		if (isSorted && opt != null) {
			if (opt.indexOf('y') != -1) {
				Sequence data = cursor.fetch();
				ColPhyTable ctmd = (ColPhyTable)getSupplementTable(false);
				if (ctmd == null) {
					append_y(data);
				} else {
					ctmd.append_y(data);
				}
			} else if (opt.indexOf('a') != -1) {
				ColPhyTable ctmd = (ColPhyTable)getSupplementTable(true);
				ctmd.mergeAppend(cursor, opt);
			} else if (opt.indexOf('m') != -1) {
				mergeAppend(cursor, opt);
			} else {
				append(cursor);
				if (opt.indexOf('i') != -1) {
					appendCache();
				}
			}
		} else if (opt != null) {
			if (opt.indexOf('y') != -1) {
				MessageManager mm = EngineMessage.get();
				throw new RQException(mm.getMessage("ds.lessKey"));
			}
			
			append(cursor);
			if (opt.indexOf('i') != -1) {
				appendCache();
			}
		} else {
			append(cursor);
		}
	}

	/**
	 * ׷???α?????ݵ????
	 * @param cursor
	 */
	public void append(ICursor cursor) throws IOException {
		getGroupTable().checkWritable();
		
		// ???û??ά?ֶ???ȡGroupTable.MIN_BLOCK_RECORD_COUNT????¼
		// ?????????3??ά?ֶ?d1??d2??d3??????ά?ֶε?ֵȡ??????MIN_BLOCK_RECORD_COUNT????¼
		// ???[d1,d2,d3]????????Ҫ??[d1,d2]ֵ??ͬ?ĸ????????????֮??Ҫ??[d1,d2,d3]ֵ??ͬ?IJ?????????
		// ?????ͬ?ij?????MAX_BLOCK_RECORD_COUNT??????MAX_BLOCK_RECORD_COUNT / 2??Ϊһ??
		// ??ÿһ?е?????д??BufferWriterȻ?????finish?õ??ֽ????飬?ٵ???compressѹ?????ݣ????д??ColumnMetaData
		// ??ά?ֶ?ʱҪ????maxValues??hasPrimaryKey??????Ա?????hasPrimaryKeyΪfalse???ٸ???
		if (cursor == null) {
			return;
		}

		Sequence data = cursor.peek(MIN_BLOCK_RECORD_COUNT);		
		if (data == null || data.length() <= 0) {
			return;
		}
		
		//?жϽṹƥ??
		DataStruct ds = data.dataStruct();
		if (ds == null) {
			MessageManager mm = EngineMessage.get();
			throw new RQException(mm.getMessage("engine.needPurePmt"));
		}
		
		ColumnMetaData []allColumns;
		if (parent == null) {
			allColumns = columns;
		} else {
			allColumns = this.allColumns;
		}
		int count = allColumns.length;
		for (int i = 0; i < count; i++) {
			if (!ds.getFieldName(i).equals(allColumns[i].getColName())) {
				MessageManager mm = EngineMessage.get();
				throw new RQException(mm.getMessage("engine.dsNotMatch"));
			}
		}
		
		//????α????ݲ???1??
		if (data.length() < MIN_BLOCK_RECORD_COUNT) {
			if (appendCache == null) {
				appendCache = data;
			} else {
				appendCache.addAll(data);
			}
			data = null;
			cursor.close();
			if (appendCache.length() >= MIN_BLOCK_RECORD_COUNT) {
				appendCache();
			}
			return;
		}
		
		//????л???????
		if (appendCache != null) {
			ICursor []cursorArray = new ICursor[2];
			cursorArray[0] = new MemoryCursor(appendCache);
			cursorArray[1] = cursor;
			cursor = new ConjxCursor(cursorArray);
			appendCache = null;
		}
		
		// ׼??д????
		prepareAppend();
		
		if (parent != null) {
			parent.appendCache();
			appendAttached(cursor);
		} else if (sortedColumns == null) {
			appendNormal(cursor);
		} else if (getSegmentCol() == null) {
			appendSorted(cursor);
		} else {
			appendSegment(cursor);
		}
		
		// ????д???ݣ????浽?ļ?
		finishAppend();
	}
	
	protected void appendSegmentBlock(int recordCount) throws IOException {
		dataBlockCount++;//???ݿ?
		totalRecordCount += recordCount;//?ܼ?¼??
		segmentWriter.writeInt32(recordCount);//
	}
	
	/**
	 * ȡ?ֶι??????ȼ?
	 * @param col
	 * @return
	 */
	public int getColumnFilterPriority(ColumnMetaData col) {
		if (sortedColumns != null) {
			int len = sortedColumns.length;
			for (int i = 0; i < len; ++i) {
				if (sortedColumns[i] == col) {
					return i;
				}
			}
			
			return len;
		} else {
			return 0;
		}
	}
	
	/**
	 * ??????????????α?
	 */
	public ICursor cursor() {
		ComTable groupTable = getGroupTable();
		groupTable.checkReadable();
		
		ICursor cs;
		if (parent != null) {
			cs = JoinTableCursor.createAnnexCursor(this);
		} else {
			cs = new Cursor(this);
		}
		
		PhyTable tmd = getSupplementTable(false);
		if (tmd == null) {
			return cs;
		} else {
			ICursor cs2 = tmd.cursor();
			return merge(cs, cs2);
		}
	}

	/**
	 * ??????????????α?
	 * @param exps ȡ???ֶα???ʽ????expsΪnullʱ????fieldsȡ????
	 * @param fields ȡ???ֶε???????
	 * @param filter ???˱???ʽ
	 * @param fkNames ָ??FK???˵??ֶ?????
	 * @param codes ָ??FK???˵?????????
	 * @param opts ?????ֶν??й?????ѡ??
	 * @param opt ѡ??
	 * @param ctx ??????
	 */
	public ICursor cursor(Expression []exps, String []fields, Expression filter, 
			String []fkNames, Sequence []codes, String []opts, String opt, Context ctx) {
		ComTable groupTable = getGroupTable();
		groupTable.checkReadable();
		
		ICursor cs = JoinTableCursor.createAnnexCursor(this, exps, fields, filter, fkNames, codes, ctx);
		if (cs == null) {
			cs = new Cursor(this, exps, fields, filter, fkNames, codes, opts, ctx);
		}
		
		PhyTable tmd = getSupplementTable(false);
		if (tmd == null) {
			return cs;
		} else {
			ICursor cs2 = tmd.cursor(exps, fields, filter, fkNames, codes, opts, opt, ctx);
			return merge(cs, cs2);
		}
	}

	public IFilter getFirstDimFilter(Expression exp, Context ctx) {
		Object obj = Cursor.parseFilter(this, exp, ctx);
		if (obj instanceof IFilter) {
			ColumnMetaData firstDim = getSortedColumns()[0];
			IFilter filter = (IFilter)obj;
			if (!filter.isMultiFieldOr() && filter.getColumn() == firstDim) {
				return filter;
			} else {
				return null;
			}
		} else if (obj instanceof ArrayList) {
			ColumnMetaData firstDim = getSortedColumns()[0];
			@SuppressWarnings("unchecked")
			ArrayList