activationclassbuilder.java

derby database source code.good for you.

/*

   Derby - Class org.apache.derby.impl.sql.compile.ActivationClassBuilder

   Copyright 1997, 2004 The Apache Software Foundation or its licensors, as applicable.

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

      http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.

 */

package org.apache.derby.impl.sql.compile;

import org.apache.derby.iapi.services.compiler.ClassBuilder;
import org.apache.derby.iapi.services.compiler.MethodBuilder;
import org.apache.derby.iapi.services.compiler.LocalField;
import org.apache.derby.iapi.reference.ClassName;


import org.apache.derby.iapi.services.sanity.SanityManager;

import org.apache.derby.iapi.sql.compile.CompilerContext;
import org.apache.derby.iapi.sql.compile.CodeGeneration;

import org.apache.derby.iapi.sql.execute.CursorResultSet;

import org.apache.derby.iapi.sql.ResultSet;

import org.apache.derby.iapi.sql.execute.ExecRow;

import org.apache.derby.iapi.types.DataTypeDescriptor;
import org.apache.derby.iapi.types.TypeId;

import org.apache.derby.iapi.error.StandardException;

import org.apache.derby.iapi.services.loader.GeneratedMethod;
import org.apache.derby.iapi.services.classfile.VMOpcode;

import java.lang.reflect.Modifier;

import java.io.PrintWriter;

import java.io.File;
import java.io.FileOutputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.Hashtable;

/**
 * ActivationClassBuilder
 * provides an interface to satisfy generation's
 * common tasks in building an activation class,
 * as well as a repository for the JavaFactory used
 * to generate the basic language constructs for the methods in the class.
 * Common tasks include the setting of a static field for each
 * expression function that gets added, the creation
 * of the execute method that gets expanded as the query tree
 * is walked, setting the superclass.
 * <p>
 * An activation class is defined for each statement. It has
 * the following basic layout: TBD
 * See the document
 * \\Jeeves\Unversioned Repository 1\Internal Technical Documents\Other\GenAndExec.doc
 * for details.
 * <p>
 * We could also verify methods as they are
 * added, to have 0 parameters, ...
 *
 * @author ames
 */
public class ActivationClassBuilder	extends	ExpressionClassBuilder
{
	///////////////////////////////////////////////////////////////////////
	//
	// CONSTANTS
	//
	///////////////////////////////////////////////////////////////////////

	///////////////////////////////////////////////////////////////////////
	//
	// STATE
	//
	///////////////////////////////////////////////////////////////////////

	private LocalField	targetResultSetField;
	private LocalField  cursorResultSetField;

	private MethodBuilder closeActivationMethod;


	///////////////////////////////////////////////////////////////////////
	//
	// CONSTRUCTOR
	//
	///////////////////////////////////////////////////////////////////////

	/**
	 * By the time this is done, it has constructed the following class:
	 * <pre>
	 *    public class #className extends #superClass {
	 *		// public void reset() { return; }
	 *		public ResultSet execute() throws StandardException {
	 *			throwIfClosed("execute");
	 *			// statements must be added here
	 *		}
	 *		public #className() { super(); }
	 *    }
	 * </pre>
	 *
	 * @exception StandardException thrown on failure
	 */
	public ActivationClassBuilder (String superClass, CompilerContext cc) throws StandardException
	{
		super( superClass, (String) null, cc );
		executeMethod = beginExecuteMethod();
	}

	///////////////////////////////////////////////////////////////////////
	//
	// ACCESSORS
	//
	///////////////////////////////////////////////////////////////////////

	/**
	  *	Get the package name that this generated class lives in
	  *
	  *	@return	package name
	  */
    public	String	getPackageName()
	{	return	CodeGeneration.GENERATED_PACKAGE_PREFIX; }

	/**
		The base class for activations is BaseActivation
	 */
	public String getBaseClassName() {
	    return ClassName.BaseActivation;
	}


	/**
	  *	Get the number of ExecRows to allocate
	  *
	  * @exception StandardException thrown on failure
	  *	@return	package name
	  */
	public	int		getRowCount()
		 throws StandardException
	{
		return	myCompCtx.getNumResultSets();
	}

	/**
	 * Generate the assignment for numSubqueries = x
	 *
	 * @param numSubqueries		The number of subqueries in the query.
	 *
	 * @return Nothing.
	 * @exception StandardException thrown on failure
	 */
	public	 void	setNumSubqueries()
	{
		int				numSubqueries = myCompCtx.getNumSubquerys();

		// If there are no subqueries then
		// the field is set to the correctly
		// value (0) by java.
		if (numSubqueries == 0)
			return;

		/* Generated code is:
		 *		numSubqueries = x;
		 */
		constructor.pushThis();
		constructor.push(numSubqueries);
		constructor.putField(ClassName.BaseActivation, "numSubqueries", "int");
		constructor.endStatement();
	}


	///////////////////////////////////////////////////////////////////////
	//
	// EXECUTE METHODS
	//
	///////////////////////////////////////////////////////////////////////

	/**
	 * By the time this is done, it has generated the following code
	 * <pre>
	 *		public ResultSet execute() throws StandardException {
	 *			throwIfClosed("execute");
	 *			// statements must be added here
	 *		}
	 *    }
	 * </pre>
	 *
	 * @exception StandardException thrown on failure
	 */
	public	MethodBuilder	beginExecuteMethod()
		throws StandardException
	{
		// create a reset method that does nothing.
		// REVISIT: this might better belong in the Activation
		// superclasses ?? not clear yet what it needs to do.

		// don't yet need a reset method here. when we do,
		// it will need to call super.reset() as well as
		// whatever it does.
		// mb = cb.newMethodBuilder(
		// 	Modifier.PUBLIC, "void", "reset");
		// mb.addStatement(javaFac.newStatement(
		//		javaFac.newSpecialMethodCall(
		//			thisExpression(),
		//			BaseActivation.CLASS_NAME,
		//			"reset", "void")));
		// mb.addStatement(javaFac.newReturnStatement());
		// mb.complete(); // there is nothing else.


		// This method is an implementation of the interface method
		// Activation - ResultSet execute()

		// create an empty execute method
		MethodBuilder mb = cb.newMethodBuilder(Modifier.PUBLIC,
			ClassName.ResultSet, "execute");
		mb.addThrownException(ClassName.StandardException);

		// put a 'throwIfClosed("execute");' statement into the execute method.
		mb.pushThis(); // instance
		mb.push("execute");
		mb.callMethod(VMOpcode.INVOKEVIRTUAL, ClassName.BaseActivation, "throwIfClosed", "void", 1);

		// call this.startExecution(), so the parent class can know an execution
		// has begun.

		mb.pushThis(); // instance
		mb.callMethod(VMOpcode.INVOKEVIRTUAL, ClassName.BaseActivation, "startExecution", "void", 0);

		return	mb;
	}

	public MethodBuilder startResetMethod() {
		MethodBuilder mb = cb.newMethodBuilder(Modifier.PUBLIC,
			"void", "reset");

		mb.addThrownException(ClassName.StandardException);
		mb.pushThis();
		mb.callMethod(VMOpcode.INVOKESPECIAL, ClassName.BaseActivation, "reset", "void", 0);


		return mb;
	}

	/**
	 * An execute method always ends in a return statement, returning
	 * the result set that has been constructed.  We want to
	 * do some bookkeeping on that statement, so we generate
	 * the return given the result set.

	   Upon entry the only word on the stack is the result set expression
	 */
	public void finishExecuteMethod(boolean genMarkAsTopNode) {

		executeMethod.pushThis();
		executeMethod.getField(ClassName.BaseActivation, "resultSet", ClassName.ResultSet);

		/* We only call markAsTopResultSet() for selects.
		 * Non-select DML marks the top NoPutResultSet in the constructor.
		 * Needed for closing down resultSet on an error.
		 */
		if (genMarkAsTopNode)
		{
			// dup the result set to leave one for the return and one for this call
			executeMethod.dup();
			executeMethod.cast(ClassName.NoPutResultSet);
			executeMethod.callMethod(VMOpcode.INVOKEINTERFACE, (String) null, "markAsTopResultSet", "void", 0);
		}

		/* return resultSet */
		executeMethod.methodReturn();
		executeMethod.complete();

		getClassBuilder().newFieldWithAccessors("getExecutionCount", "setExecutionCount",
			Modifier.PROTECTED, true, "int");

		getClassBuilder().newFieldWithAccessors("getRowCountCheckVector", "setRowCountCheckVector",
			Modifier.PROTECTED, true, "java.util.Vector");

		getClassBuilder().newFieldWithAccessors("getStalePlanCheckInterval", "setStalePlanCheckInterval",
			Modifier.PROTECTED, true, "int");

		if (closeActivationMethod != null) {
			closeActivationMethod.methodReturn();
			closeActivationMethod.complete();
		}
	}

	///////////////////////////////////////////////////////////////////////
	//
	// CURSOR SUPPORT
	//
	///////////////////////////////////////////////////////////////////////

	/**
	 * Updatable cursors
	 * need to add a getter method for use in BaseActivation to access
	 * the result set that identifies target rows for a positioned
	 * update or delete.
	 * <p>
	 * The code that is generated is:
	 * <pre><verbatim>
	 *  public CursorResultSet getTargetResultSet() {
	 *	    return targetResultSet;
	 *  }
	 *
	 *  public CursorResultSet getCursorResultSet() {
	 *		return cursorResultSet;
	 *  }
	 * </verbatim></pre>
	 *
	 */
	public void addCursorPositionCode() {

		// the getter
		// This method is an implementation of the interface method
		// CursorActivation - CursorResultSet getTargetResultSet()
		MethodBuilder getter = cb.newMethodBuilder(Modifier.PUBLIC, 
			ClassName.CursorResultSet, "getTargetResultSet");

		getter.getField(targetResultSetField);
		getter.methodReturn();
		getter.complete();

		// This method is an implementation of the interface method
		// CursorActivation - CursorResultSet getCursorResultSet()

		getter = cb.newMethodBuilder(Modifier.PUBLIC, 
			ClassName.CursorResultSet, "getCursorResultSet");

		getter.getField(cursorResultSetField);
		getter.methodReturn();
		getter.complete();
	}

	/**
	 * Updatable cursors
	 * need to add a field and its initialization
	 * for use in BaseActivation to access the result set that
	 * identifies target rows for a positioned update or delete.
	 * <p>
	 * The code that is generated is:
	 * <pre><verbatim>
	 *  private CursorResultSet targetResultSet;
	 *
	 * </verbatim></pre>
	 *
	 * The expression that is generated is:
	 * <pre><verbatim>
	 *  (ResultSet) (targetResultSet = (CursorResultSet) #expression#)
	 * </verbatim></pre>
	 *
	 */
	public void rememberCursorTarget(MethodBuilder mb) {

		// the field
		targetResultSetField = cb.addField(ClassName.CursorResultSet,
					"targetResultSet",
					Modifier.PRIVATE);

		mb.cast(ClassName.CursorResultSet);
		mb.putField(targetResultSetField);
		mb.cast(ClassName.NoPutResultSet);
	}

	/**
	 * Updatable cursors
	 * need to add a field and its initialization
	 * for use in BaseActivation to access the result set that
	 * identifies cursor result rows for a positioned update or delete.
	 * <p>
	 * The code that is generated is:
	 * <pre><verbatim>
	 *  private CursorResultSet cursorResultSet;
	 *
	 * </verbatim></pre>
	 *
	 * The expression that is generated is:
	 * <pre><verbatim>
	 *  (ResultSet) (cursorResultSet = (CursorResultSet) #expression#)
	 * </verbatim></pre>

       The expression must be the top stack word when this method is called.
	 *
	 */
	public void rememberCursor(MethodBuilder mb) {

		// the field
		cursorResultSetField = cb.addField(ClassName.CursorResultSet,
					"cursorResultSet",
					Modifier.PRIVATE);

		mb.cast(ClassName.CursorResultSet);
		mb.putField(cursorResultSetField);
		mb.cast(ClassName.ResultSet);
	}

	///////////////////////////////////////////////////////////////////////
	//
	// CURRENT DATE/TIME SUPPORT
	//
	///////////////////////////////////////////////////////////////////////

	/*
		The first time a current datetime is needed, create the class
		level support for it. The first half of the logic is in our parent
		class. Then we add logic here to tidy up for ResultSet management.
	 */
	protected LocalField getCurrentSetup()
	{
		if (cdtField != null) return cdtField;

		LocalField lf = super.getCurrentSetup();

		// 3) the execute method gets a statement (prior to the return)
		//    to tell cdt to restart:
		//	  cdt.forget();

		executeMethod.getField(lf);
		executeMethod.callMethod(VMOpcode.INVOKEVIRTUAL, (String) null, "forget", "void", 0);

		// 4) a resultSetClosed method is set up to be passed to
		//    the outermost result set, if it is an open/close result set,
		//    so that cdt can be told to forget when a result set closes:
		//	  GeneratedMethod rscm; // the name is just a generated name, simpler.
		//    void rscm() {
		//		cdt.forget();
		//	  }
		MethodBuilder mb = newExprFun();
		mb.getField(lf); // the instance
		mb.callMethod(VMOpcode.INVOKEVIRTUAL, (String) null, "forget", "void", 0);
		mb.pushNull("java.lang.Object");
		mb.methodReturn();
		mb.complete();
		
		resultSetClosedMethod = mb;

		return lf;
	}

	//////////////////////////////////////////////////////////////////////////
	//
	//	NAMED PARAMETER METHODS
	//
	//////////////////////////////////////////////////////////////////////////

	/**
	 *	Generates a parameter reference. Only implemented for Filters right now.
	 *
	 *	@param	name		Parameter name.
	 *	@param	position	Parameter id.
	 *	@param	dataType	Parameter datatype.
	 *  @param	mb			The method to put the generated code into
	 *
	 *	@return	an expression representing the parameter reference.
	 *
	 * 	@exception StandardException thrown on failure
	 */
	public	void	getParameterReference( String				name,
											   int					position,
											   DataTypeDescriptor		dataType,
											   MethodBuilder		mb )
		 throws StandardException
	{
		if (SanityManager.DEBUG)
			SanityManager.NOTREACHED();
	}


	public MethodBuilder getCloseActivationMethod() {

		if (closeActivationMethod == null) {
			closeActivationMethod = cb.newMethodBuilder(Modifier.PUBLIC, "void", "closeActivationAction");
			closeActivationMethod.addThrownException("java.lang.Exception");
		}
		return closeActivationMethod;
	}
}