blood-analysis/src/main/java/com/guozhi/bloodanalysis/parser/common/UpdateParser.java

/*
  Copyright 2015 Dell Inc.
  ALL RIGHTS RESERVED.
*/
package com.guozhi.bloodanalysis.parser.common;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import com.guozhi.bloodanalysis.parser.utils.ExprToColumn;
import com.guozhi.bloodanalysis.parser.utils.KColumnProvider;
import com.guozhi.bloodanalysis.parser.utils.SpUtils;
import com.guozhi.bloodanalysis.parser.vo.KColumn;
import com.guozhi.bloodanalysis.parser.vo.VTable;
import gudusoft.gsqlparser.nodes.TExpression;
import gudusoft.gsqlparser.nodes.TJoinList;
import gudusoft.gsqlparser.nodes.TResultColumn;
import gudusoft.gsqlparser.nodes.TResultColumnList;
import gudusoft.gsqlparser.nodes.TTable;
import gudusoft.gsqlparser.nodes.TTableList;
import gudusoft.gsqlparser.nodes.TWhereClause;
import gudusoft.gsqlparser.stmt.TSelectSqlStatement;
import gudusoft.gsqlparser.stmt.TUpdateSqlStatement;
import lombok.NoArgsConstructor;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Component;

@Component
@NoArgsConstructor
public class UpdateParser{
	private TUpdateSqlStatement mUpdateStmt;
	private List<KColumn> mColumns;
	private ParserContext mParserContext;

	@Autowired
	ApplicationContext applicationContext;
	
	public UpdateParser(TUpdateSqlStatement stmt, ParserContext context) {
	    mUpdateStmt = stmt;
	    mColumns = new ArrayList<KColumn>();
	    this.mParserContext = context;
	}

	public void parse() {
	    TTable targetTable = mUpdateStmt.getTargetTable();
		String[] nameInfo = SpUtils.analyseTableName(targetTable.getFullName());
	    VTable updateTable = new VTable(targetTable.getName(), targetTable.getName());
		if (nameInfo[0] != null){
			List<Map<String,Integer>> list = mParserContext.getDbList();
			if (list != null && list.size() >0){
				for (Map<String, Integer> map : list) {
					updateTable.db = map.get(nameInfo[0]) == null ? mParserContext.getDefaultDb() : map.get(nameInfo[0]);
				}
			}
		}else{
			updateTable.db=mParserContext.getDefaultDb();
		}
		updateTable.schema=nameInfo[1];
		if(updateTable.schema==null){
			updateTable.schema=mParserContext.getDefaultSchema();
		}
	    boolean exportColumn = false;
	    VTable createdTable = mParserContext.findExistedTable(updateTable.getFullName(),true);
	    if (createdTable == null) {
	        exportColumn = true;
	    }
	
	    mParserContext.setCurrentTable(updateTable);
	    TTableList tableList = mUpdateStmt.tables;
	    if (tableList != null) {
	        for (int i = 0; i < tableList.size(); i++) {
	            TTable fromTable = tableList.getTable(i);
	            VTable table=analyseTable(fromTable);
	            if(table.getFullName().equals(updateTable.getFullName()))continue;
	
	            mParserContext.getTableInCurrentStatement().add(table);
	
	
	        }
	    }
	    TJoinList joinList=mUpdateStmt.getReferenceJoins();
	    if(joinList!=null){
	        for(int i=0;i<joinList.size();i++){
	            System.out.println(joinList.getJoin(i));
	        }
	    }
	
	    TWhereClause whereClause = mUpdateStmt.getWhereClause();
	    if(whereClause!=null) {
	        TExpression conditionExpr = whereClause.getCondition();
	    }
	//    List<KColumn> conditionColumns = new ArrayList<KColumn>();
	//    conditionColumns.add(new ExprToColumn(mUpdateStmt, mParserContext, false).exprVisit(conditionExpr));
	    TResultColumnList rcList = mUpdateStmt.getResultColumnList();
	
	
	    for (int i = 0; i < rcList.size(); i++) {
	        TResultColumn rc = rcList.getResultColumn(i);
	        TExpression expr = rc.getExpr();
	        KColumn dest= new KColumn();
	        dest.db=updateTable.db;
	        dest.schema=updateTable.schema;
	        dest.tableName=updateTable.getName();
	        dest.columnName=expr.getLeftOperand().toString();
	        //表的状态是临时表还是实体表
	        dest.isEvTable = updateTable.isCreated();
	        dest.export=exportColumn;
	        KColumn src= new ExprToColumn(mUpdateStmt, mParserContext, false).exprVisit(expr.getRightOperand()) ;
	        dest.addRefColumn(src);
	        mColumns.add(dest);
	    }
	    //依赖关系只计算不同表之间的
	   /* for (KColumn column : conditionColumns) {
	        //TODO 列所属表是否相同的判断需要加强
	        System.out.println(column.tableName);
	        if (column != null && !column.tableName.equals(targetTable.getName())) {
	            for (KColumn mColumn : mColumns) {
	
	                mColumn.addRefColumn(column);
	
	            }
	        }
	
	    }*/
	
	}

	public List<KColumn> getParseResult() {
	    return mColumns;
	}
	
	private VTable analyseTable(TTable table) {
	    String fullName = table.getFullName();
	    String tableAlias = table.getAliasName();
	    VTable vTable = null;
	    if (StringUtils.isBlank(fullName)) {//子查询
	        vTable = new VTable(SpUtils.generateId(table.toString(), tableAlias));
	    } else if (StringUtils.isNotBlank(fullName)) {//普通表名
	        String[] nameInfo = SpUtils.analyseTableName(fullName);
	        vTable = new VTable(nameInfo[2], nameInfo[2]);
			if (nameInfo[0] != null){
				List<Map<String,Integer>> list = mParserContext.getDbList();
				if (list != null && list.size() >0){
					for (Map<String, Integer> map : list) {
						vTable.db = map.get(nameInfo[0]) == null ? mParserContext.getDefaultDb() : map.get(nameInfo[0]);
					}
				}
			}else{
				vTable.db=mParserContext.getDefaultDb();
			}
			vTable.schema=nameInfo[1];
			if(vTable.schema==null){
				vTable.schema=mParserContext.getDefaultSchema();
			}
	    }
	    if (StringUtils.isNotBlank(tableAlias)) {
	        vTable.setAlias(tableAlias);
	    }
	    //已知的表
	    VTable createdTable = mParserContext.findExistedTable(vTable.getFullName(),true);
	    if (createdTable != null) {
	    	createdTable.setAlias(vTable.alias);
	        return createdTable;
	    }
	    switch (table.getTableType()) {
	        case objectname:
	            vTable.setRealTable(true);
	            //真实数据库中的表，查找表对应关系
	            vTable.addColumns(new KColumnProvider().getColumns(null,table.getFullName(), mParserContext));
	            break;
	        case subquery:
	            TSelectSqlStatement subQuery = table.getSubquery();
	            VTable currentTable = mParserContext.getCurrentTable();
	            SelectParser sp = applicationContext.getBean(SelectParser.class);
				sp.initWithTable(subQuery, mParserContext, vTable, true);
	            sp.parse();
	            mParserContext.setCurrentTable(currentTable);
	            //创建依赖关系
	            vTable.addColumns(sp.getParseResult());
	            break;   //subquery
	
	        case function:
	            //table.getFuncCall();
	            break;
	        case tableExpr:
	            break;
	        case rowList:
	            break;
	        //SQL Server only
	        case containsTable:
	            break;
	        case freetextTable:
	            break;
	
	        default:
	            break;
	    }
	    mParserContext.addVTable(vTable);
	    return vTable;
	}
}