prerna.sablecc2.translations.ReplaceDatasourceTranslation Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of semoss Show documentation
SEMOSS
The newest version!
package prerna.sablecc2.translations;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PushbackReader;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Vector;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

import prerna.om.Insight;
import prerna.query.querystruct.SelectQueryStruct;
import prerna.query.querystruct.transform.QSRenameColumnConverter;
import prerna.query.querystruct.transform.QsToPixelConverter;
import prerna.sablecc2.PixelPreProcessor;
import prerna.sablecc2.PixelUtility;
import prerna.sablecc2.lexer.Lexer;
import prerna.sablecc2.lexer.LexerException;
import prerna.sablecc2.node.AOperation;
import prerna.sablecc2.node.ARoutineConfiguration;
import prerna.sablecc2.node.PRoutine;
import prerna.sablecc2.node.Start;
import prerna.sablecc2.om.GenRowStruct;
import prerna.sablecc2.om.NounStore;
import prerna.sablecc2.om.PixelDataType;
import prerna.sablecc2.parser.Parser;
import prerna.sablecc2.parser.ParserException;
import prerna.util.Utility;

public class ReplaceDatasourceTranslation extends AbstractDatasourceModificationTranslation {

	private static final Logger logger = LogManager.getLogger(ReplaceDatasourceTranslation.class);

	// this will store the list of pixels that were passed in
	private List pixels = new Vector();
	
	private List> replacements = null;
	private int currentIndex = 0;
	
	// a replacement for the given input
	private String origPixelPortion = null;
	private String replacementSourcePixel = null;
	private Map headerMods = null;
	
	// contain the query struct
	private SelectQueryStruct importQs;
	private String importStr;
	
	// this is for the special case
	// where the index isn't provided
	// and we just want to replace the first source
	private boolean replaceFirst = false;
	private boolean doneReplaceFirst = false;
	
	public ReplaceDatasourceTranslation(Insight insight) {
		super(insight);
	}
	
	@Override
	public void caseARoutineConfiguration(ARoutineConfiguration node) {
		List copy = new ArrayList(node.getRoutine());
		for(PRoutine e : copy) {
    		this.resultKey = "$RESULT_" + e.hashCode();

			String expression = e.toString();
			logger.info("Processing " + Utility.cleanLogString(expression));

			boolean process = false;
			for(String iType : importTypes) {
				if(expression.contains(iType)) {
					process = true;
					break;
				}
			}
			
			// only execute pixels that at least contain the import
			if(process) {
				e.apply(this);
				
				// if we ended up finding something to store
				if(this.replacementSourcePixel != null && this.origPixelPortion != null) {
					
					String newExpression = null;
					if(this.importQs != null && this.headerMods != null) {
						// need to replace the columns as well
						newExpression = this.replacementSourcePixel 
								+ " | " + QsToPixelConverter.getPixel(QSRenameColumnConverter.convertQs(this.importQs, this.headerMods, true), false)
								+ " | " + this.importStr + ";";
					} else {
						// just replace the source
						newExpression = expression.replace(this.origPixelPortion, this.replacementSourcePixel);
					}
					this.pixels.add(newExpression);

					
					// now we need to null replacement
					this.replacementSourcePixel = null;
					this.origPixelPortion = null;
					this.importQs = null;
					this.headerMods = null;
					this.importStr = null;
					
				} else {
		        	expression = PixelUtility.recreateOriginalPixelExpression(expression, encodingList, encodedToOriginal);
					this.pixels.add(expression);
				}
				
			} else {
	        	expression = PixelUtility.recreateOriginalPixelExpression(expression, encodingList, encodedToOriginal);
				this.pixels.add(expression);
			}
			
			// update the index
			this.currentIndex++;
		}
	}
	
	@Override
	public void inAOperation(AOperation node) {
		super.inAOperation(node);
		defaultIn(node);
		
		// looking for data sources
		String reactorId = node.getId().toString().trim();
		if(importTypes.contains(reactorId)) {
			tryPerformReplacement(node.toString().trim());
		} else if(reactorId.equals("Import") || reactorId.equals("Merge")) {
			this.importStr = node.toString();
		}
	}
	
	private void tryPerformReplacement(String nodeString) {
		if(this.replaceFirst && !this.doneReplaceFirst) {
			// we need to replace 
			Map singleReplacement = this.replacements.get(0);
			
			// set the values for the replacement
			this.origPixelPortion = nodeString;
			this.replacementSourcePixel = (String) singleReplacement.get("pixel");
			this.headerMods = (Map) singleReplacement.get("headerMod");
			
			this.doneReplaceFirst = true;
		} else if(!doneReplaceFirst) { // add the else if for performance
			// try and see if there is a replacement that matches
			// based on the index
			for(Map replacementOption : this.replacements) {
				int index = (int) replacementOption.get("index");
				if(index == this.currentIndex) {
					// set the values for the replacement
					this.origPixelPortion = nodeString;
					this.replacementSourcePixel = (String) replacementOption.get("pixel");
					this.headerMods = (Map) replacementOption.get("headerMod");

					break;
				}
			}
		}
	}
	
	@Override
	public void outAOperation(AOperation node) {
		super.outAOperation(node);

		if(this.replacementSourcePixel != null && prevReactor != null) {
			// we are doing some kind of replacement
			// so we are going to try to find the import qs
			NounStore nouns = prevReactor.getNounStore();
			GenRowStruct grs = nouns.getNoun(PixelDataType.QUERY_STRUCT.getKey());
			if(grs != null && !grs.isEmpty()) {
				this.importQs = (SelectQueryStruct) grs.get(0);
			} else {
				grs = prevReactor.getCurRow();
				if(grs != null && !grs.isEmpty()) {
					List