0001: /*
0002: * sqlc 1
0003: * SQL Compiler
0004: * Copyright (C) 2003 Hammurapi Group
0005: *
0006: * This program is free software; you can redistribute it and/or
0007: * modify it under the terms of the GNU Lesser General Public
0008: * License as published by the Free Software Foundation; either
0009: * version 2 of the License, or (at your option) any later version.
0010: *
0011: * This program is distributed in the hope that it will be useful,
0012: * but WITHOUT ANY WARRANTY; without even the implied warranty of
0013: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
0014: * Lesser General Public License for more details.
0015: *
0016: * You should have received a copy of the GNU Lesser General Public
0017: * License along with this library; if not, write to the Free Software
0018: * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
0019: *
0020: * URL: http://www.hammurapi.biz/products/sqlc/index.html
0021: * e-Mail: support@hammurapi.biz
0022: */
0023: package biz.hammurapi.sqlc;
0024:
0025: import java.io.File;
0026: import java.io.IOException;
0027: import java.sql.PreparedStatement;
0028: import java.sql.ResultSetMetaData;
0029: import java.sql.SQLException;
0030: import java.util.ArrayList;
0031: import java.util.Collection;
0032: import java.util.HashSet;
0033: import java.util.Iterator;
0034: import java.util.Properties;
0035: import java.util.Set;
0036:
0037: import org.apache.bcel.Constants;
0038: import org.apache.bcel.classfile.JavaClass;
0039: import org.apache.bcel.generic.ACONST_NULL;
0040: import org.apache.bcel.generic.ALOAD;
0041: import org.apache.bcel.generic.ARETURN;
0042: import org.apache.bcel.generic.ClassGen;
0043: import org.apache.bcel.generic.DUP;
0044: import org.apache.bcel.generic.InstructionFactory;
0045: import org.apache.bcel.generic.InstructionList;
0046: import org.apache.bcel.generic.LDC;
0047: import org.apache.bcel.generic.RETURN;
0048: import org.apache.bcel.generic.ReferenceType;
0049:
0050: import biz.hammurapi.codegen.Class;
0051: import biz.hammurapi.codegen.ClassGeneratorBase;
0052: import biz.hammurapi.codegen.Consumer;
0053: import biz.hammurapi.codegen.GenerationException;
0054: import biz.hammurapi.codegen.GenerationListener;
0055: import biz.hammurapi.codegen.MethodPrototype;
0056: import biz.hammurapi.convert.Converter;
0057: import biz.hammurapi.sql.FirstColumnProjector;
0058: import biz.hammurapi.sql.FirstColumnSmartProjector;
0059: import biz.hammurapi.sql.Parameterizer;
0060: import biz.hammurapi.sql.Projector;
0061: import biz.hammurapi.sql.RowProcessor;
0062: import biz.hammurapi.sql.SQLProcessor;
0063: import biz.hammurapi.sql.SmartProjector;
0064: import biz.hammurapi.sql.hypersonic.HypersonicInMemoryDataSource;
0065: import biz.hammurapi.sql.metadata.ColumnDescriptor;
0066: import biz.hammurapi.sql.metadata.DefaultGenerationPolicy;
0067: import biz.hammurapi.sql.metadata.GenerationPolicy;
0068: import biz.hammurapi.sql.metadata.ParameterDescriptor;
0069: import biz.hammurapi.util.Parameter;
0070:
0071: /**
0072: * @author Pavel Vlasov
0073: * @version $Revision: 1.11 $
0074: */
0075: public class NamedQuery extends NamedInterfaceGeneratingStatement {
0076: private boolean isSingleRow;
0077:
0078: /**
0079: * @param name
0080: * @param sql
0081: * @param isSingleRow
0082: * @throws SQLException
0083: */
0084: public NamedQuery(String name, String description,
0085: boolean isSingleRow, String sql, SQLProcessor processor,
0086: GenerationPolicy policy, boolean hasNullableParameters,
0087: boolean generateMutators) throws SQLException {
0088: super (name, description, sql, processor, policy,
0089: hasNullableParameters, generateMutators);
0090: this .isSingleRow = isSingleRow;
0091: }
0092:
0093: public NamedQuery(String name, String description,
0094: boolean isSingleRow, String sql,
0095: Collection parameterDescriptors,
0096: Collection parameterDescriptors2,
0097: Collection columnDescriptors, boolean generateMutators) {
0098: super (name, description, sql, parameterDescriptors,
0099: parameterDescriptors2, generateMutators);
0100: this .isSingleRow = isSingleRow;
0101: this .columnDescriptors.addAll(columnDescriptors);
0102: }
0103:
0104: /**
0105: * @param policy
0106: * @param hasNullableParameters
0107: * @param ps
0108: * @throws SQLException
0109: */
0110: protected void processPreparedStatement(GenerationPolicy policy,
0111: boolean hasNullableParameters, PreparedStatement ps)
0112: throws SQLException {
0113: super .processPreparedStatement(policy, hasNullableParameters,
0114: ps);
0115: ResultSetMetaData metadata = ps.getMetaData();
0116: if (metadata == null) {
0117: throw new SQLException("Metadata is null for statement: "
0118: + getSql());
0119: }
0120:
0121: for (int i = 1, cc = metadata.getColumnCount(); i <= cc; i++) {
0122: ColumnDescriptor cd = new ColumnDescriptor();
0123: cd.setDbType(metadata.getColumnType(i));
0124: cd.setName(policy.generateColumnName(metadata
0125: .getColumnName(i)));
0126: cd.setJavaType(policy
0127: .getJavaType(metadata.getColumnType(i)));
0128: cd.setLabel(policy.generateLabel(cd.getName()));
0129: cd.setDbName(metadata.getColumnName(i));
0130: cd.setPosition(i);
0131: cd.setClassName(metadata.getColumnClassName(i));
0132: cd
0133: .setNullable(metadata.isNullable(i) != ResultSetMetaData.columnNoNulls);
0134: columnDescriptors.add(cd);
0135: }
0136: }
0137:
0138: /**
0139: * @param packageName
0140: * @param consumer
0141: * @param c
0142: * @param iFactory
0143: * @param parameters
0144: * @param type
0145: * @throws GenerationException
0146: */
0147: private void generateGetDatabaseBackedCollectionFC(
0148: String packageName, Class c) throws GenerationException {
0149: MethodPrototype mp = new MethodPrototype(c,
0150: getEngineMethodsVisibility()
0151: + " java.util.Collection get" + name + "()",
0152: parameterDescriptors);
0153: InstructionList il = new InstructionList();
0154:
0155: // 0: aload_0
0156: il.append(new ALOAD(0));
0157: // 1: getfield org.jincarnate.util.SampleClass.processor Lcom/pavelvlasov/sql/SQLProcessor; (52)
0158: il.append(c.createGetField("_processor"));
0159: // 4: ldc "ABC" (61)
0160: il.append(new LDC(c.getClassGen().getConstantPool().addString(
0161: getSql())));
0162: if (parameterDescriptors.isEmpty()) {
0163: il.append(new ACONST_NULL());
0164: } else {
0165: // 6: new <org.jincarnate.util.SampleClass$PackageQueryParameterizer> (63)
0166: String parameterizerClass = generateParameterizerName(c
0167: .getClassGen().getClassName());
0168: il.append(c.getInstructionFactory().createNew(
0169: parameterizerClass));
0170: // 9: dup
0171: il.append(new DUP());
0172: // 10: aload_1
0173: // 11: iload_2
0174: // 12: iload_3
0175: Iterator it = parameterDescriptors.iterator();
0176: while (it.hasNext()) {
0177: il.append(mp.createVariableLoad(((Parameter) it.next())
0178: .getName()));
0179: }
0180: // 13: invokespecial org.jincarnate.util.SampleClass$PackageQueryParameterizer.<init> (Ljava/lang/String;SI)V (66)
0181: il.append(c.createInvoke(parameterizerClass,
0182: "void <init>()", parameterDescriptors,
0183: Constants.INVOKESPECIAL));
0184: }
0185: // 16: new <biz.hammurapi.sql.FirstColumnProjector> (68)
0186: String projectorClass = FirstColumnProjector.class.getName();
0187: il.append(c.getInstructionFactory().createNew(projectorClass));
0188: // 19: dup
0189: il.append(new DUP());
0190: // 20: invokespecial biz.hammurapi.sql.FirstColumnProjector.<init> ()V (69)
0191: il.append(c.createInvoke(projectorClass, "void <init>()", null,
0192: Constants.INVOKESPECIAL));
0193: // 23: invokevirtual biz.hammurapi.sql.SQLProcessor.project (Ljava/lang/String;Lcom/pavelvlasov/sql/Parameterizer;Lcom/pavelvlasov/sql/Projector;)Ljava/util/Collection; (75)
0194: il.append(c.createInvoke(SQLProcessor.class.getName(),
0195: "java.util.Collection project(java.lang.String,"
0196: + Parameterizer.class.getName() + ","
0197: + Projector.class.getName() + ")", null,
0198: Constants.INVOKEVIRTUAL));
0199: // 26: areturn
0200: il.append(new ARETURN());
0201:
0202: mp
0203: .addMethod(
0204: il,
0205: null,
0206: "Executes query, returns database backed collection with elements of type of the first column. "
0207: + getDescription());
0208: }
0209:
0210: /**
0211: * @param packageName
0212: * @param consumer
0213: * @param c
0214: * @param iFactory
0215: * @param parameters
0216: * @param type
0217: * @throws GenerationException
0218: */
0219: private void generateGetDatabaseBackedCollectionConvertedFC(
0220: String packageName, Class c) throws GenerationException {
0221: Collection parameters = new ArrayList(parameterDescriptors);
0222: final String converterParameterName = uniquifyParameter(
0223: parameters, "converter");
0224: parameters.add(new Parameter() {
0225: public String getName() {
0226: return converterParameterName;
0227: }
0228:
0229: public String getType() {
0230: return Converter.class.getName();
0231: }
0232: });
0233:
0234: MethodPrototype mp = new MethodPrototype(c,
0235: getEngineMethodsVisibility()
0236: + " java.util.Collection get" + name + "()",
0237: parameters);
0238: InstructionList il = new InstructionList();
0239:
0240: // 0: aload_0
0241: il.append(new ALOAD(0));
0242: // 1: getfield org.jincarnate.util.SampleClass.processor Lcom/pavelvlasov/sql/SQLProcessor; (52)
0243: il.append(c.createGetField("_processor"));
0244: // 4: ldc "ABC" (61)
0245: il.append(new LDC(c.getClassGen().getConstantPool().addString(
0246: getSql())));
0247: if (parameterDescriptors.isEmpty()) {
0248: il.append(new ACONST_NULL());
0249: } else {
0250: // 6: new <org.jincarnate.util.SampleClass$PackageQueryParameterizer> (63)
0251: String parameterizerClass = generateParameterizerName(c
0252: .getClassGen().getClassName());
0253: il.append(c.getInstructionFactory().createNew(
0254: parameterizerClass));
0255: // 9: dup
0256: il.append(new DUP());
0257: // 10: aload_1
0258: // 11: iload_2
0259: // 12: iload_3
0260: Iterator it = parameterDescriptors.iterator();
0261: while (it.hasNext()) {
0262: il.append(mp.createVariableLoad(((Parameter) it.next())
0263: .getName()));
0264: }
0265: // 13: invokespecial org.jincarnate.util.SampleClass$PackageQueryParameterizer.<init> (Ljava/lang/String;SI)V (66)
0266: il.append(c.createInvoke(parameterizerClass,
0267: "void <init>()", parameterDescriptors,
0268: Constants.INVOKESPECIAL));
0269: }
0270: // 16: new <biz.hammurapi.sql.FirstColumnProjector> (68)
0271: String projectorClass = FirstColumnSmartProjector.class
0272: .getName();
0273: il.append(c.getInstructionFactory().createNew(projectorClass));
0274: // 19: dup
0275: il.append(new DUP());
0276: // 8 15:aconst_null
0277: il.append(new ACONST_NULL());
0278: // 7 14:aload_1
0279: il.append(mp.createVariableLoad(converterParameterName));
0280:
0281: // 20: invokespecial biz.hammurapi.sql.FirstColumnProjector.<init> ()V (69)
0282: il.append(c.createInvoke(projectorClass,
0283: "void <init>(java.lang.Class,"
0284: + Converter.class.getName() + ")", null,
0285: Constants.INVOKESPECIAL));
0286: // 23: invokevirtual biz.hammurapi.sql.SQLProcessor.project (Ljava/lang/String;Lcom/pavelvlasov/sql/Parameterizer;Lcom/pavelvlasov/sql/Projector;)Ljava/util/Collection; (75)
0287: il.append(c.createInvoke(SQLProcessor.class.getName(),
0288: "java.util.Collection project(java.lang.String,"
0289: + Parameterizer.class.getName() + ","
0290: + Projector.class.getName() + ")", null,
0291: Constants.INVOKEVIRTUAL));
0292: // 26: areturn
0293: il.append(new ARETURN());
0294:
0295: mp
0296: .addMethod(
0297: il,
0298: null,
0299: "Executes query, returns database backed collection with elements of type of the first column. "
0300: + "If converter is not null then it converts elements. "
0301: + getDescription());
0302: }
0303:
0304: private String uniquifyParameter(Collection parameters, String name) {
0305: Set names = new HashSet();
0306: Iterator it = parameters.iterator();
0307: while (it.hasNext()) {
0308: names.add(((Parameter) it.next()).getName());
0309: }
0310:
0311: String ret = name;
0312: int i = 0;
0313: while (names.contains(ret)) {
0314: ret = name + "_" + i++;
0315: }
0316:
0317: return ret;
0318: }
0319:
0320: /**
0321: * @param packageName
0322: * @param consumer
0323: * @param c
0324: * @param iFactory
0325: * @param parameters
0326: * @param type
0327: * @throws GenerationException
0328: */
0329: private void generateGetDatabaseBackedCollectionTargetedFC(
0330: String packageName, Class c) throws GenerationException {
0331: Collection parameters = new ArrayList(parameterDescriptors);
0332: final String targetClassParameterName = uniquifyParameter(
0333: parameters, "targetClass");
0334: parameters.add(new Parameter() {
0335: public String getName() {
0336: return targetClassParameterName;
0337: }
0338:
0339: public String getType() {
0340: return "java.lang.Class";
0341: }
0342: });
0343:
0344: MethodPrototype mp = new MethodPrototype(c,
0345: getEngineMethodsVisibility()
0346: + " java.util.Collection get" + name + "()",
0347: parameters);
0348: InstructionList il = new InstructionList();
0349:
0350: // 0: aload_0
0351: il.append(new ALOAD(0));
0352: // 1: getfield org.jincarnate.util.SampleClass.processor Lcom/pavelvlasov/sql/SQLProcessor; (52)
0353: il.append(c.createGetField("_processor"));
0354: // 4: ldc "ABC" (61)
0355: il.append(new LDC(c.getClassGen().getConstantPool().addString(
0356: getSql())));
0357: if (parameterDescriptors.isEmpty()) {
0358: il.append(new ACONST_NULL());
0359: } else {
0360: // 6: new <org.jincarnate.util.SampleClass$PackageQueryParameterizer> (63)
0361: String parameterizerClass = generateParameterizerName(c
0362: .getClassGen().getClassName());
0363: il.append(c.getInstructionFactory().createNew(
0364: parameterizerClass));
0365: // 9: dup
0366: il.append(new DUP());
0367: // 10: aload_1
0368: // 11: iload_2
0369: // 12: iload_3
0370: Iterator it = parameterDescriptors.iterator();
0371: while (it.hasNext()) {
0372: il.append(mp.createVariableLoad(((Parameter) it.next())
0373: .getName()));
0374: }
0375: // 13: invokespecial org.jincarnate.util.SampleClass$PackageQueryParameterizer.<init> (Ljava/lang/String;SI)V (66)
0376: il.append(c.createInvoke(parameterizerClass,
0377: "void <init>()", parameterDescriptors,
0378: Constants.INVOKESPECIAL));
0379: }
0380: // 16: new <biz.hammurapi.sql.FirstColumnProjector> (68)
0381: String projectorClass = FirstColumnSmartProjector.class
0382: .getName();
0383: il.append(c.getInstructionFactory().createNew(projectorClass));
0384: // 19: dup
0385: il.append(new DUP());
0386: // 7 14:aload_1
0387: il.append(mp.createVariableLoad(targetClassParameterName));
0388: // 8 15:aconst_null
0389: il.append(new ACONST_NULL());
0390:
0391: // 20: invokespecial biz.hammurapi.sql.FirstColumnProjector.<init> ()V (69)
0392: il.append(c.createInvoke(projectorClass,
0393: "void <init>(java.lang.Class,"
0394: + Converter.class.getName() + ")", null,
0395: Constants.INVOKESPECIAL));
0396: // 23: invokevirtual biz.hammurapi.sql.SQLProcessor.project (Ljava/lang/String;Lcom/pavelvlasov/sql/Parameterizer;Lcom/pavelvlasov/sql/Projector;)Ljava/util/Collection; (75)
0397: il.append(c.createInvoke(SQLProcessor.class.getName(),
0398: "java.util.Collection project(java.lang.String,"
0399: + Parameterizer.class.getName() + ","
0400: + Projector.class.getName() + ")", null,
0401: Constants.INVOKEVIRTUAL));
0402: // 26: areturn
0403: il.append(new ARETURN());
0404:
0405: mp
0406: .addMethod(
0407: il,
0408: null,
0409: "Executes query, returns database backed collection with elements of type of the first column. "
0410: + "If target class is not null then elements are instances of target class created from the first column values. "
0411: + getDescription());
0412: }
0413:
0414: /**
0415: * @param packageName
0416: * @param consumer
0417: * @param c
0418: * @param iFactory
0419: * @param parameters
0420: * @param type
0421: * @throws GenerationException
0422: */
0423: private void generateGetDatabaseBackedCollection(
0424: String packageName, Class c) throws GenerationException {
0425: MethodPrototype mp = new MethodPrototype(c,
0426: getEngineMethodsVisibility()
0427: + " java.util.Collection get" + name + "()",
0428: parameterDescriptors);
0429:
0430: // Collection getXXX(parameters)
0431: InstructionList il = new InstructionList();
0432:
0433: // 0: aload_0
0434: il.append(new ALOAD(0));
0435: // 1: getfield org.jincarnate.util.SampleClass.processor Lcom/pavelvlasov/sql/SQLProcessor; (46)
0436: il.append(c.createGetField("_processor"));
0437: // 4: ldc "ABC" (52)
0438: il.append(new LDC(c.getClassGen().getConstantPool().addString(
0439: getSql())));
0440: InstructionFactory iFactory = c.getInstructionFactory();
0441: if (parameterDescriptors.isEmpty()) {
0442: il.append(new ACONST_NULL());
0443: } else {
0444: // 6: new <org.jincarnate.util.ABCParameterizer> (54)
0445: String parameterizerClass = generateParameterizerName(c
0446: .getClassGen().getClassName());
0447: il.append(iFactory.createNew(parameterizerClass));
0448: // 9: dup
0449: il.append(new DUP());
0450: // 10: iload_1
0451: Iterator it = parameterDescriptors.iterator();
0452: while (it.hasNext()) {
0453: il.append(mp.createVariableLoad(((Parameter) it.next())
0454: .getName()));
0455: }
0456: // 11: invokespecial org.jincarnate.util.ABCParameterizer.<init> (I)V (57)
0457: il.append(c.createInvoke(parameterizerClass,
0458: "void <init>()", parameterDescriptors,
0459: Constants.INVOKESPECIAL));
0460: }
0461:
0462: // 4 7:new #48 <Class SmartProjector>
0463: String smartProjectorName = SmartProjector.class.getName();
0464: il.append(iFactory.createNew(smartProjectorName));
0465: // 5 10:dup
0466: il.append(new DUP());
0467: // 6 11:getstatic #24 <Field Class IMPL_CLASS>
0468: il.append(c.createGetField(getImplClassFieldName(packageName)));
0469: // 7 14:invokespecial #51 <Method void SmartProjector(Class)>
0470: il.append(c.createInvoke(smartProjectorName,
0471: "void <init>(java.lang.Class)", null,
0472: Constants.INVOKESPECIAL));
0473:
0474: // 25: invokevirtual biz.hammurapi.sql.SQLProcessor.project (Ljava/lang/String;Lcom/pavelvlasov/sql/Parameterizer;Lcom/pavelvlasov/sql/Projector;)Ljava/util/Collection; (68)
0475: il.append(c.createInvoke(SQLProcessor.class.getName(),
0476: "java.util.Collection project(java.lang.String,"
0477: + Parameterizer.class.getName() + ","
0478: + Projector.class.getName() + ")", null,
0479: Constants.INVOKEVIRTUAL));
0480: // 28: areturn
0481: il.append(new ARETURN());
0482:
0483: mp.setAttribute("element-type", getInterfaceName(packageName));
0484: mp.addMethod(il, null,
0485: "Executes query, returns database backed collection with elements of type "
0486: + getInterfaceName(packageName) + ". "
0487: + getDescription());
0488: }
0489:
0490: /**
0491: * @param packageName
0492: * @param consumer
0493: * @param c
0494: * @param iFactory
0495: * @param parameters
0496: * @param type
0497: * @throws GenerationException
0498: */
0499: private void generateGetDatabaseBackedCollectionTargeted(
0500: String packageName, Class c) throws GenerationException {
0501: Collection parameters = new ArrayList(parameterDescriptors);
0502: final String targetClassParameterName = uniquifyParameter(
0503: parameters, "targetClass");
0504: parameters.add(new Parameter() {
0505: public String getName() {
0506: return targetClassParameterName;
0507: }
0508:
0509: public String getType() {
0510: return "java.lang.Class";
0511: }
0512: });
0513:
0514: MethodPrototype mp = new MethodPrototype(c,
0515: getEngineMethodsVisibility()
0516: + " java.util.Collection get" + name + "()",
0517: parameters);
0518:
0519: // Collection getXXX(parameters)
0520: InstructionList il = new InstructionList();
0521:
0522: // 0: aload_0
0523: il.append(new ALOAD(0));
0524: // 1: getfield org.jincarnate.util.SampleClass.processor Lcom/pavelvlasov/sql/SQLProcessor; (46)
0525: il.append(c.createGetField("_processor"));
0526: // 4: ldc "ABC" (52)
0527: il.append(new LDC(c.getClassGen().getConstantPool().addString(
0528: getSql())));
0529: InstructionFactory iFactory = c.getInstructionFactory();
0530: if (parameterDescriptors.isEmpty()) {
0531: il.append(new ACONST_NULL());
0532: } else {
0533: // 6: new <org.jincarnate.util.ABCParameterizer> (54)
0534: String parameterizerClass = generateParameterizerName(c
0535: .getClassGen().getClassName());
0536: il.append(iFactory.createNew(parameterizerClass));
0537: // 9: dup
0538: il.append(new DUP());
0539: // 10: iload_1
0540: Iterator it = parameterDescriptors.iterator();
0541: while (it.hasNext()) {
0542: il.append(mp.createVariableLoad(((Parameter) it.next())
0543: .getName()));
0544: }
0545: // 11: invokespecial org.jincarnate.util.ABCParameterizer.<init> (I)V (57)
0546: il.append(c.createInvoke(parameterizerClass,
0547: "void <init>()", parameterDescriptors,
0548: Constants.INVOKESPECIAL));
0549: }
0550:
0551: // 4 7:new #48 <Class SmartProjector>
0552: String smartProjectorName = SmartProjector.class.getName();
0553: il.append(iFactory.createNew(smartProjectorName));
0554: // 5 10:dup
0555: il.append(new DUP());
0556: // 6 11:getstatic #24 <Field Class IMPL_CLASS>
0557: il.append(c.createGetField(getImplClassFieldName(packageName)));
0558: // 7 14:aload_1
0559: il.append(mp.createVariableLoad(targetClassParameterName));
0560: // 8 15:aconst_null
0561: il.append(new ACONST_NULL());
0562: // 7 14:invokespecial #51 <Method void SmartProjector(Class)>
0563: il.append(c.createInvoke(smartProjectorName,
0564: "void <init>(java.lang.Class,java.lang.Class,"
0565: + Converter.class.getName() + ")", null,
0566: Constants.INVOKESPECIAL));
0567:
0568: // 25: invokevirtual biz.hammurapi.sql.SQLProcessor.project (Ljava/lang/String;Lcom/pavelvlasov/sql/Parameterizer;Lcom/pavelvlasov/sql/Projector;)Ljava/util/Collection; (68)
0569: il.append(c.createInvoke(SQLProcessor.class.getName(),
0570: "java.util.Collection project(java.lang.String,"
0571: + Parameterizer.class.getName() + ","
0572: + Projector.class.getName() + ")", null,
0573: Constants.INVOKEVIRTUAL));
0574: // 28: areturn
0575: il.append(new ARETURN());
0576:
0577: mp.setAttribute("element-type", getInterfaceName(packageName));
0578: mp
0579: .addMethod(
0580: il,
0581: null,
0582: "Executes query, returns database backed collection with elements of type "
0583: + getInterfaceName(packageName)
0584: + ". "
0585: + "If targetClass is not null then elements will be of targetClass type"
0586: + getDescription());
0587: }
0588:
0589: /**
0590: * @param packageName
0591: * @param consumer
0592: * @param c
0593: * @param iFactory
0594: * @param parameters
0595: * @param type
0596: * @throws GenerationException
0597: */
0598: private void generateGetDatabaseBackedCollectionConverted(
0599: String packageName, Class c) throws GenerationException {
0600: Collection parameters = new ArrayList(parameterDescriptors);
0601: final String converterParameterName = uniquifyParameter(
0602: parameters, "converter");
0603: parameters.add(new Parameter() {
0604: public String getName() {
0605: return converterParameterName;
0606: }
0607:
0608: public String getType() {
0609: return Converter.class.getName();
0610: }
0611: });
0612:
0613: MethodPrototype mp = new MethodPrototype(c,
0614: getEngineMethodsVisibility()
0615: + " java.util.Collection get" + name + "()",
0616: parameters);
0617:
0618: // Collection getXXX(parameters)
0619: InstructionList il = new InstructionList();
0620:
0621: // 0: aload_0
0622: il.append(new ALOAD(0));
0623: // 1: getfield org.jincarnate.util.SampleClass.processor Lcom/pavelvlasov/sql/SQLProcessor; (46)
0624: il.append(c.createGetField("_processor"));
0625: // 4: ldc "ABC" (52)
0626: il.append(new LDC(c.getClassGen().getConstantPool().addString(
0627: getSql())));
0628: InstructionFactory iFactory = c.getInstructionFactory();
0629: if (parameterDescriptors.isEmpty()) {
0630: il.append(new ACONST_NULL());
0631: } else {
0632: // 6: new <org.jincarnate.util.ABCParameterizer> (54)
0633: String parameterizerClass = generateParameterizerName(c
0634: .getClassGen().getClassName());
0635: il.append(iFactory.createNew(parameterizerClass));
0636: // 9: dup
0637: il.append(new DUP());
0638: // 10: iload_1
0639: Iterator it = parameterDescriptors.iterator();
0640: while (it.hasNext()) {
0641: il.append(mp.createVariableLoad(((Parameter) it.next())
0642: .getName()));
0643: }
0644: // 11: invokespecial org.jincarnate.util.ABCParameterizer.<init> (I)V (57)
0645: il.append(c.createInvoke(parameterizerClass,
0646: "void <init>()", parameterDescriptors,
0647: Constants.INVOKESPECIAL));
0648: }
0649:
0650: // 4 7:new #48 <Class SmartProjector>
0651: String smartProjectorName = SmartProjector.class.getName();
0652: il.append(iFactory.createNew(smartProjectorName));
0653: // 5 10:dup
0654: il.append(new DUP());
0655: // 6 11:getstatic #24 <Field Class IMPL_CLASS>
0656: il.append(c.createGetField(getImplClassFieldName(packageName)));
0657: // 8 15:aconst_null
0658: il.append(new ACONST_NULL());
0659: // 7 14:aload_1
0660: il.append(mp.createVariableLoad(converterParameterName));
0661: // 7 14:invokespecial #51 <Method void SmartProjector(Class)>
0662: il.append(c.createInvoke(smartProjectorName,
0663: "void <init>(java.lang.Class,java.lang.Class,"
0664: + Converter.class.getName() + ")", null,
0665: Constants.INVOKESPECIAL));
0666:
0667: // 25: invokevirtual biz.hammurapi.sql.SQLProcessor.project (Ljava/lang/String;Lcom/pavelvlasov/sql/Parameterizer;Lcom/pavelvlasov/sql/Projector;)Ljava/util/Collection; (68)
0668: il.append(c.createInvoke(SQLProcessor.class.getName(),
0669: "java.util.Collection project(java.lang.String,"
0670: + Parameterizer.class.getName() + ","
0671: + Projector.class.getName() + ")", null,
0672: Constants.INVOKEVIRTUAL));
0673: // 28: areturn
0674: il.append(new ARETURN());
0675:
0676: mp.setAttribute("element-type", getInterfaceName(packageName));
0677: mp
0678: .addMethod(
0679: il,
0680: null,
0681: "Executes query, returns database backed collection with elements of type "
0682: + getInterfaceName(packageName)
0683: + ". "
0684: + "If converter is not null then elements will be results of conversion."
0685: + getDescription());
0686: }
0687:
0688: private void generateGetCollectionFC(String packageName, Class c)
0689: throws GenerationException {
0690: Collection parameters = new ArrayList(parameterDescriptors);
0691: final String receiverParameterName = uniquifyParameter(
0692: parameters, "receiver");
0693: parameters.add(new Parameter() {
0694: public String getName() {
0695: return receiverParameterName;
0696: }
0697:
0698: public String getType() {
0699: return Collection.class.getName();
0700: }
0701: });
0702:
0703: MethodPrototype mp = new MethodPrototype(c,
0704: getEngineMethodsVisibility()
0705: + " java.util.Collection get" + name
0706: + "() throws " + SQLException.class.getName(),
0707: parameters);
0708:
0709: // Collection getXXX(parameters, Collection)
0710: InstructionList il = new InstructionList();
0711:
0712: // 0: aload_0
0713: il.append(new ALOAD(0));
0714: // 1: getfield org.jincarnate.util.SampleClass.processor Lcom/pavelvlasov/sql/SQLProcessor; (52)
0715: il.append(c.createGetField("_processor"));
0716: // 4: ldc "ABC" (61)
0717: il.append(new LDC(c.getClassGen().getConstantPool().addString(
0718: getSql())));
0719: if (parameterDescriptors.isEmpty()) {
0720: il.append(new ACONST_NULL());
0721: } else {
0722: // 6: new <org.jincarnate.util.SampleClass$PackageQueryParameterizer> (63)
0723: String parameterizerClass = generateParameterizerName(c
0724: .getClassGen().getClassName());
0725: il.append(c.getInstructionFactory().createNew(
0726: parameterizerClass));
0727: // 9: dup
0728: il.append(new DUP());
0729: // 10: aload_1
0730: // 11: iload_2
0731: // 12: iload_3
0732: Iterator it = parameterDescriptors.iterator();
0733: while (it.hasNext()) {
0734: il.append(mp.createVariableLoad(((Parameter) it.next())
0735: .getName()));
0736: }
0737: // 13: invokespecial org.jincarnate.util.SampleClass$PackageQueryParameterizer.<init> (Ljava/lang/String;SI)V (66)
0738: il.append(c.createInvoke(parameterizerClass,
0739: "void <init>()", parameterDescriptors,
0740: Constants.INVOKESPECIAL));
0741: }
0742: // 16: new <biz.hammurapi.sql.FirstColumnProjector> (68)
0743: String projectorClass = FirstColumnProjector.class.getName();
0744: il.append(c.getInstructionFactory().createNew(projectorClass));
0745: // 19: dup
0746: il.append(new DUP());
0747: // 20: invokespecial biz.hammurapi.sql.FirstColumnProjector.<init> ()V (69)
0748: il.append(c.createInvoke(projectorClass, "void <init>()", null,
0749: Constants.INVOKESPECIAL));
0750: // 23: aload %4
0751: il.append(mp.createVariableLoad(receiverParameterName));
0752: // 25: invokevirtual biz.hammurapi.sql.SQLProcessor.project (Ljava/lang/String;Lcom/pavelvlasov/sql/Parameterizer;Lcom/pavelvlasov/sql/Projector;Ljava/util/Collection;)Ljava/util/Collection; (75)
0753: il.append(c.createInvoke(SQLProcessor.class.getName(),
0754: "java.util.Collection project(java.lang.String,"
0755: + Parameterizer.class.getName() + ","
0756: + Projector.class.getName()
0757: + ",java.util.Collection)", null,
0758: Constants.INVOKEVIRTUAL));
0759: // 28: areturn
0760: il.append(new ARETURN());
0761:
0762: mp
0763: .addMethod(
0764: il,
0765: null,
0766: "Executes query, populates collection with values from the first column and returns the collection. "
0767: + getDescription());
0768: }
0769:
0770: private void generateGetCollectionTargetedFC(String packageName,
0771: Class c) throws GenerationException {
0772: Collection parameters = new ArrayList(parameterDescriptors);
0773: final String targetClassParameterName = uniquifyParameter(
0774: parameters, "targetClass");
0775: final String receiverParameterName = uniquifyParameter(
0776: parameters, "receiver");
0777: parameters.add(new Parameter() {
0778: public String getName() {
0779: return receiverParameterName;
0780: }
0781:
0782: public String getType() {
0783: return Collection.class.getName();
0784: }
0785: });
0786:
0787: parameters.add(new Parameter() {
0788: public String getName() {
0789: return targetClassParameterName;
0790: }
0791:
0792: public String getType() {
0793: return "java.lang.Class";
0794: }
0795: });
0796:
0797: MethodPrototype mp = new MethodPrototype(c,
0798: getEngineMethodsVisibility()
0799: + " java.util.Collection get" + name
0800: + "() throws " + SQLException.class.getName(),
0801: parameters);
0802:
0803: // Collection getXXX(parameters, Collection)
0804: InstructionList il = new InstructionList();
0805:
0806: // 0: aload_0
0807: il.append(new ALOAD(0));
0808: // 1: getfield org.jincarnate.util.SampleClass.processor Lcom/pavelvlasov/sql/SQLProcessor; (52)
0809: il.append(c.createGetField("_processor"));
0810: // 4: ldc "ABC" (61)
0811: il.append(new LDC(c.getClassGen().getConstantPool().addString(
0812: getSql())));
0813: if (parameterDescriptors.isEmpty()) {
0814: il.append(new ACONST_NULL());
0815: } else {
0816: // 6: new <org.jincarnate.util.SampleClass$PackageQueryParameterizer> (63)
0817: String parameterizerClass = generateParameterizerName(c
0818: .getClassGen().getClassName());
0819: il.append(c.getInstructionFactory().createNew(
0820: parameterizerClass));
0821: // 9: dup
0822: il.append(new DUP());
0823: // 10: aload_1
0824: // 11: iload_2
0825: // 12: iload_3
0826: Iterator it = parameterDescriptors.iterator();
0827: while (it.hasNext()) {
0828: il.append(mp.createVariableLoad(((Parameter) it.next())
0829: .getName()));
0830: }
0831: // 13: invokespecial org.jincarnate.util.SampleClass$PackageQueryParameterizer.<init> (Ljava/lang/String;SI)V (66)
0832: il.append(c.createInvoke(parameterizerClass,
0833: "void <init>()", parameterDescriptors,
0834: Constants.INVOKESPECIAL));
0835: }
0836: // 16: new <biz.hammurapi.sql.FirstColumnProjector> (68)
0837: String projectorClass = FirstColumnSmartProjector.class
0838: .getName();
0839: il.append(c.getInstructionFactory().createNew(projectorClass));
0840: // 19: dup
0841: il.append(new DUP());
0842: // 7 14:aload_1
0843: il.append(mp.createVariableLoad(targetClassParameterName));
0844: // 8 15:aconst_null
0845: il.append(new ACONST_NULL());
0846: // 20: invokespecial biz.hammurapi.sql.FirstColumnProjector.<init> ()V (69)
0847: il.append(c.createInvoke(projectorClass,
0848: "void <init>(java.lang.Class,"
0849: + Converter.class.getName() + ")", null,
0850: Constants.INVOKESPECIAL));
0851: // 23: aload %4
0852: il.append(mp.createVariableLoad(receiverParameterName));
0853: // 25: invokevirtual biz.hammurapi.sql.SQLProcessor.project (Ljava/lang/String;Lcom/pavelvlasov/sql/Parameterizer;Lcom/pavelvlasov/sql/Projector;Ljava/util/Collection;)Ljava/util/Collection; (75)
0854: il.append(c.createInvoke(SQLProcessor.class.getName(),
0855: "java.util.Collection project(java.lang.String,"
0856: + Parameterizer.class.getName() + ","
0857: + Projector.class.getName()
0858: + ",java.util.Collection)", null,
0859: Constants.INVOKEVIRTUAL));
0860: // 28: areturn
0861: il.append(new ARETURN());
0862:
0863: mp
0864: .addMethod(
0865: il,
0866: null,
0867: "Executes query, populates collection with values from the first column and returns the collection. "
0868: + "If target class is not null instances of target class are instantiated from first column values"
0869: + getDescription());
0870: }
0871:
0872: private void generateGetCollectionConvertedFC(String packageName,
0873: Class c) throws GenerationException {
0874: Collection parameters = new ArrayList(parameterDescriptors);
0875: final String receiverParameterName = uniquifyParameter(
0876: parameters, "receiver");
0877: parameters.add(new Parameter() {
0878: public String getName() {
0879: return receiverParameterName;
0880: }
0881:
0882: public String getType() {
0883: return Collection.class.getName();
0884: }
0885: });
0886:
0887: final String converterParameterName = uniquifyParameter(
0888: parameters, "converter");
0889: parameters.add(new Parameter() {
0890: public String getName() {
0891: return converterParameterName;
0892: }
0893:
0894: public String getType() {
0895: return Converter.class.getName();
0896: }
0897: });
0898:
0899: MethodPrototype mp = new MethodPrototype(c,
0900: getEngineMethodsVisibility()
0901: + " java.util.Collection get" + name
0902: + "() throws " + SQLException.class.getName(),
0903: parameters);
0904:
0905: // Collection getXXX(parameters, Collection)
0906: InstructionList il = new InstructionList();
0907:
0908: // 0: aload_0
0909: il.append(new ALOAD(0));
0910: // 1: getfield org.jincarnate.util.SampleClass.processor Lcom/pavelvlasov/sql/SQLProcessor; (52)
0911: il.append(c.createGetField("_processor"));
0912: // 4: ldc "ABC" (61)
0913: il.append(new LDC(c.getClassGen().getConstantPool().addString(
0914: getSql())));
0915: if (parameterDescriptors.isEmpty()) {
0916: il.append(new ACONST_NULL());
0917: } else {
0918: // 6: new <org.jincarnate.util.SampleClass$PackageQueryParameterizer> (63)
0919: String parameterizerClass = generateParameterizerName(c
0920: .getClassGen().getClassName());
0921: il.append(c.getInstructionFactory().createNew(
0922: parameterizerClass));
0923: // 9: dup
0924: il.append(new DUP());
0925: // 10: aload_1
0926: // 11: iload_2
0927: // 12: iload_3
0928: Iterator it = parameterDescriptors.iterator();
0929: while (it.hasNext()) {
0930: il.append(mp.createVariableLoad(((Parameter) it.next())
0931: .getName()));
0932: }
0933: // 13: invokespecial org.jincarnate.util.SampleClass$PackageQueryParameterizer.<init> (Ljava/lang/String;SI)V (66)
0934: il.append(c.createInvoke(parameterizerClass,
0935: "void <init>()", parameterDescriptors,
0936: Constants.INVOKESPECIAL));
0937: }
0938: // 16: new <biz.hammurapi.sql.FirstColumnProjector> (68)
0939: String projectorClass = FirstColumnSmartProjector.class
0940: .getName();
0941: il.append(c.getInstructionFactory().createNew(projectorClass));
0942: // 19: dup
0943: il.append(new DUP());
0944: // 8 15:aconst_null
0945: il.append(new ACONST_NULL());
0946: // 7 14:aload_1
0947: il.append(mp.createVariableLoad(converterParameterName));
0948: // 20: invokespecial biz.hammurapi.sql.FirstColumnProjector.<init> ()V (69)
0949: il.append(c.createInvoke(projectorClass,
0950: "void <init>(java.lang.Class,"
0951: + Converter.class.getName() + ")", null,
0952: Constants.INVOKESPECIAL));
0953: // 23: aload %4
0954: il.append(mp.createVariableLoad(receiverParameterName));
0955: // 25: invokevirtual biz.hammurapi.sql.SQLProcessor.project (Ljava/lang/String;Lcom/pavelvlasov/sql/Parameterizer;Lcom/pavelvlasov/sql/Projector;Ljava/util/Collection;)Ljava/util/Collection; (75)
0956: il.append(c.createInvoke(SQLProcessor.class.getName(),
0957: "java.util.Collection project(java.lang.String,"
0958: + Parameterizer.class.getName() + ","
0959: + Projector.class.getName()
0960: + ",java.util.Collection)", null,
0961: Constants.INVOKEVIRTUAL));
0962: // 28: areturn
0963: il.append(new ARETURN());
0964:
0965: mp
0966: .addMethod(
0967: il,
0968: null,
0969: "Executes query, populates collection with values from the first column and returns the collection. "
0970: + "Elements get converted by the converter if it is not null."
0971: + getDescription());
0972: }
0973:
0974: private void generateGetCollection(String packageName, Class c)
0975: throws GenerationException {
0976: Collection parameters = new ArrayList(parameterDescriptors);
0977: final String receiverParameterName = uniquifyParameter(
0978: parameters, "receiver");
0979: parameters.add(new Parameter() {
0980: public String getName() {
0981: return receiverParameterName;
0982: }
0983:
0984: public String getType() {
0985: return Collection.class.getName();
0986: }
0987: });
0988:
0989: MethodPrototype mp = new MethodPrototype(c,
0990: getEngineMethodsVisibility()
0991: + " java.util.Collection get" + name
0992: + "() throws " + SQLException.class.getName(),
0993: parameters);
0994:
0995: // Collection getXXX(parameters, Collection)
0996: InstructionList il = new InstructionList();
0997:
0998: // 0: aload_0
0999: il.append(new ALOAD(0));
1000: // 1: getfield org.jincarnate.util.SampleClass.processor Lcom/pavelvlasov/sql/SQLProcessor; (52)
1001: il.append(c.createGetField("_processor"));
1002: // 4: ldc "ABC" (61)
1003: il.append(new LDC(c.getClassGen().getConstantPool().addString(
1004: getSql())));
1005: InstructionFactory iFactory = c.getInstructionFactory();
1006: if (parameterDescriptors.isEmpty()) {
1007: il.append(new ACONST_NULL());
1008: } else {
1009: // 6: new <org.jincarnate.util.SampleClass$PackageQueryParameterizer> (63)
1010: String parameterizerClass = generateParameterizerName(c
1011: .getClassGen().getClassName());
1012: il.append(iFactory.createNew(parameterizerClass));
1013: // 9: dup
1014: il.append(new DUP());
1015: // 10: aload_1
1016: // 11: iload_2
1017: // 12: iload_3
1018: Iterator it = parameterDescriptors.iterator();
1019: while (it.hasNext()) {
1020: il.append(mp.createVariableLoad(((Parameter) it.next())
1021: .getName()));
1022: }
1023: // 13: invokespecial org.jincarnate.util.SampleClass$PackageQueryParameterizer.<init> (Ljava/lang/String;SI)V (66)
1024: il.append(c.createInvoke(parameterizerClass,
1025: "void <init>()", parameterDescriptors,
1026: Constants.INVOKESPECIAL));
1027: }
1028:
1029: // 4 7:new #48 <Class SmartProjector>
1030: String smartProjectorName = SmartProjector.class.getName();
1031: il.append(iFactory.createNew(smartProjectorName));
1032: // 5 10:dup
1033: il.append(new DUP());
1034: // 6 11:getstatic #24 <Field Class IMPL_CLASS>
1035: il.append(c.createGetField(getImplClassFieldName(packageName)));
1036: // 7 14:invokespecial #51 <Method void SmartProjector(Class)>
1037: il.append(c.createInvoke(smartProjectorName,
1038: "void <init>(java.lang.Class)", null,
1039: Constants.INVOKESPECIAL));
1040:
1041: // 19: aload %4
1042: il.append(mp.createVariableLoad(receiverParameterName));
1043: // 21: invokevirtual biz.hammurapi.sql.SQLProcessor.project (Ljava/lang/String;Lcom/pavelvlasov/sql/Parameterizer;Lcom/pavelvlasov/sql/Projector;Ljava/util/Collection;)Ljava/util/Collection; (72)
1044: il.append(c.createInvoke(SQLProcessor.class.getName(),
1045: "java.util.Collection project(java.lang.String,"
1046: + Parameterizer.class.getName() + ","
1047: + Projector.class.getName()
1048: + ",java.util.Collection)", null,
1049: Constants.INVOKEVIRTUAL));
1050: // 24: areturn
1051: il.append(new ARETURN());
1052:
1053: mp.setAttribute("element-type", getInterfaceName(packageName));
1054: mp.addMethod(il, null,
1055: "Executes query, populates collection with elements of type "
1056: + getInterfaceName(packageName)
1057: + " and returns populated collection. "
1058: + getDescription());
1059: }
1060:
1061: private void generateToRowProcessor(String packageName, Class c)
1062: throws GenerationException {
1063: Collection parameters = new ArrayList(parameterDescriptors);
1064: final String processorParameterName = uniquifyParameter(
1065: parameters, "processor");
1066: parameters.add(new Parameter() {
1067: public String getName() {
1068: return processorParameterName;
1069: }
1070:
1071: public String getType() {
1072: return RowProcessor.class.getName();
1073: }
1074: });
1075:
1076: MethodPrototype mp = new MethodPrototype(c,
1077: getEngineMethodsVisibility() + " void process" + name
1078: + "() throws " + SQLException.class.getName(),
1079: parameters);
1080:
1081: // void processXXX(parameters, RowProcessor)
1082: InstructionList il = new InstructionList();
1083:
1084: // 0: aload_0
1085: il.append(new ALOAD(0));
1086: // 1:getfield #62 <Field SQLProcessor _processor>
1087: il.append(c.createGetField("_processor"));
1088: // 4: ldc "ABC" (61)
1089: il.append(new LDC(c.getClassGen().getConstantPool().addString(
1090: getSql())));
1091: InstructionFactory iFactory = c.getInstructionFactory();
1092: if (parameterDescriptors.isEmpty()) {
1093: il.append(new ACONST_NULL());
1094: } else {
1095: // 6: new <org.jincarnate.util.SampleClass$PackageQueryParameterizer> (63)
1096: String parameterizerClass = generateParameterizerName(c
1097: .getClassGen().getClassName());
1098: il.append(iFactory.createNew(parameterizerClass));
1099: // 9: dup
1100: il.append(new DUP());
1101: // 10: aload_1
1102: // 11: iload_2
1103: // 12: iload_3
1104: Iterator it = parameterDescriptors.iterator();
1105: while (it.hasNext()) {
1106: il.append(mp.createVariableLoad(((Parameter) it.next())
1107: .getName()));
1108: }
1109: // 13: invokespecial org.jincarnate.util.SampleClass$PackageQueryParameterizer.<init> (Ljava/lang/String;SI)V (66)
1110: il.append(c.createInvoke(parameterizerClass,
1111: "void <init>()", parameterDescriptors,
1112: Constants.INVOKESPECIAL));
1113: }
1114:
1115: // 19: aload %4
1116: il.append(mp.createVariableLoad(processorParameterName));
1117: // 10 18:invokevirtual #94 <Method void SQLProcessor.processSelect(String, Parameterizer, RowProcessor)>
1118: il.append(c.createInvoke(SQLProcessor.class.getName(),
1119: "void processSelect(java.lang.String,"
1120: + Parameterizer.class.getName() + ","
1121: + RowProcessor.class.getName() + ")", null,
1122: Constants.INVOKEVIRTUAL));
1123: // 24: return
1124: il.append(new RETURN());
1125:
1126: mp
1127: .addMethod(
1128: il,
1129: null,
1130: "Executes query, iterates over rows and invokes methods of RowProcessor for each row. "
1131: + getDescription());
1132: }
1133:
1134: private void generateGetCollectionTargeted(String packageName,
1135: Class c) throws GenerationException {
1136: Collection parameters = new ArrayList(parameterDescriptors);
1137: final String targetClassParameterName = uniquifyParameter(
1138: parameters, "targetClass");
1139: final String receiverParameterName = uniquifyParameter(
1140: parameters, "receiver");
1141: parameters.add(new Parameter() {
1142: public String getName() {
1143: return receiverParameterName;
1144: }
1145:
1146: public String getType() {
1147: return Collection.class.getName();
1148: }
1149: });
1150:
1151: parameters.add(new Parameter() {
1152: public String getName() {
1153: return targetClassParameterName;
1154: }
1155:
1156: public String getType() {
1157: return "java.lang.Class";
1158: }
1159: });
1160:
1161: MethodPrototype mp = new MethodPrototype(c,
1162: getEngineMethodsVisibility()
1163: + " java.util.Collection get" + name
1164: + "() throws " + SQLException.class.getName(),
1165: parameters);
1166:
1167: // Collection getXXX(parameters, Collection)
1168: InstructionList il = new InstructionList();
1169:
1170: // 0: aload_0
1171: il.append(new ALOAD(0));
1172: // 1: getfield org.jincarnate.util.SampleClass.processor Lcom/pavelvlasov/sql/SQLProcessor; (52)
1173: il.append(c.createGetField("_processor"));
1174: // 4: ldc "ABC" (61)
1175: il.append(new LDC(c.getClassGen().getConstantPool().addString(
1176: getSql())));
1177: InstructionFactory iFactory = c.getInstructionFactory();
1178: if (parameterDescriptors.isEmpty()) {
1179: il.append(new ACONST_NULL());
1180: } else {
1181: // 6: new <org.jincarnate.util.SampleClass$PackageQueryParameterizer> (63)
1182: String parameterizerClass = generateParameterizerName(c
1183: .getClassGen().getClassName());
1184: il.append(iFactory.createNew(parameterizerClass));
1185: // 9: dup
1186: il.append(new DUP());
1187: // 10: aload_1
1188: // 11: iload_2
1189: // 12: iload_3
1190: Iterator it = parameterDescriptors.iterator();
1191: while (it.hasNext()) {
1192: il.append(mp.createVariableLoad(((Parameter) it.next())
1193: .getName()));
1194: }
1195: // 13: invokespecial org.jincarnate.util.SampleClass$PackageQueryParameterizer.<init> (Ljava/lang/String;SI)V (66)
1196: il.append(c.createInvoke(parameterizerClass,
1197: "void <init>()", parameterDescriptors,
1198: Constants.INVOKESPECIAL));
1199: }
1200:
1201: // 4 7:new #48 <Class SmartProjector>
1202: String smartProjectorName = SmartProjector.class.getName();
1203: il.append(iFactory.createNew(smartProjectorName));
1204: // 5 10:dup
1205: il.append(new DUP());
1206: // 6 11:getstatic #24 <Field Class IMPL_CLASS>
1207: il.append(c.createGetField(getImplClassFieldName(packageName)));
1208: // 7 14:aload_1
1209: il.append(mp.createVariableLoad(targetClassParameterName));
1210: // 8 15:aconst_null
1211: il.append(new ACONST_NULL());
1212: // 7 14:invokespecial #51 <Method void SmartProjector(Class)>
1213: il.append(c.createInvoke(smartProjectorName,
1214: "void <init>(java.lang.Class,java.lang.Class,"
1215: + Converter.class.getName() + ")", null,
1216: Constants.INVOKESPECIAL));
1217:
1218: // 19: aload %4
1219: il.append(mp.createVariableLoad(receiverParameterName));
1220: // 21: invokevirtual biz.hammurapi.sql.SQLProcessor.project (Ljava/lang/String;Lcom/pavelvlasov/sql/Parameterizer;Lcom/pavelvlasov/sql/Projector;Ljava/util/Collection;)Ljava/util/Collection; (72)
1221: il.append(c.createInvoke(SQLProcessor.class.getName(),
1222: "java.util.Collection project(java.lang.String,"
1223: + Parameterizer.class.getName() + ","
1224: + Projector.class.getName()
1225: + ",java.util.Collection)", null,
1226: Constants.INVOKEVIRTUAL));
1227: // 24: areturn
1228: il.append(new ARETURN());
1229:
1230: mp.setAttribute("element-type", getInterfaceName(packageName));
1231: mp
1232: .addMethod(
1233: il,
1234: null,
1235: "Executes query, populates collection with elements of type "
1236: + getInterfaceName(packageName)
1237: + " and returns populated collection. "
1238: + "If targetClass is not null then elements will be of targetClass type. "
1239: + getDescription());
1240: }
1241:
1242: private void generateGetCollectionConverted(String packageName,
1243: Class c) throws GenerationException {
1244: Collection parameters = new ArrayList(parameterDescriptors);
1245: final String receiverParameterName = uniquifyParameter(
1246: parameters, "receiver");
1247: parameters.add(new Parameter() {
1248: public String getName() {
1249: return receiverParameterName;
1250: }
1251:
1252: public String getType() {
1253: return Collection.class.getName();
1254: }
1255: });
1256:
1257: final String converterParameterName = uniquifyParameter(
1258: parameters, "converter");
1259: parameters.add(new Parameter() {
1260: public String getName() {
1261: return converterParameterName;
1262: }
1263:
1264: public String getType() {
1265: return Converter.class.getName();
1266: }
1267: });
1268:
1269: MethodPrototype mp = new MethodPrototype(c,
1270: getEngineMethodsVisibility()
1271: + " java.util.Collection get" + name
1272: + "() throws " + SQLException.class.getName(),
1273: parameters);
1274:
1275: // Collection getXXX(parameters, Collection)
1276: InstructionList il = new InstructionList();
1277:
1278: // 0: aload_0
1279: il.append(new ALOAD(0));
1280: // 1: getfield org.jincarnate.util.SampleClass.processor Lcom/pavelvlasov/sql/SQLProcessor; (52)
1281: il.append(c.createGetField("_processor"));
1282: // 4: ldc "ABC" (61)
1283: il.append(new LDC(c.getClassGen().getConstantPool().addString(
1284: getSql())));
1285: InstructionFactory iFactory = c.getInstructionFactory();
1286: if (parameterDescriptors.isEmpty()) {
1287: il.append(new ACONST_NULL());
1288: } else {
1289: // 6: new <org.jincarnate.util.SampleClass$PackageQueryParameterizer> (63)
1290: String parameterizerClass = generateParameterizerName(c
1291: .getClassGen().getClassName());
1292: il.append(iFactory.createNew(parameterizerClass));
1293: // 9: dup
1294: il.append(new DUP());
1295: // 10: aload_1
1296: // 11: iload_2
1297: // 12: iload_3
1298: Iterator it = parameterDescriptors.iterator();
1299: while (it.hasNext()) {
1300: il.append(mp.createVariableLoad(((Parameter) it.next())
1301: .getName()));
1302: }
1303: // 13: invokespecial org.jincarnate.util.SampleClass$PackageQueryParameterizer.<init> (Ljava/lang/String;SI)V (66)
1304: il.append(c.createInvoke(parameterizerClass,
1305: "void <init>()", parameterDescriptors,
1306: Constants.INVOKESPECIAL));
1307: }
1308:
1309: // 4 7:new #48 <Class SmartProjector>
1310: String smartProjectorName = SmartProjector.class.getName();
1311: il.append(iFactory.createNew(smartProjectorName));
1312: // 5 10:dup
1313: il.append(new DUP());
1314: // 6 11:getstatic #24 <Field Class IMPL_CLASS>
1315: il.append(c.createGetField(getImplClassFieldName(packageName)));
1316: // 8 15:aconst_null
1317: il.append(new ACONST_NULL());
1318: // 7 14:aload_1
1319: il.append(mp.createVariableLoad(converterParameterName));
1320: // 7 14:invokespecial #51 <Method void SmartProjector(Class)>
1321: il.append(c.createInvoke(smartProjectorName,
1322: "void <init>(java.lang.Class,java.lang.Class,"
1323: + Converter.class.getName() + ")", null,
1324: Constants.INVOKESPECIAL));
1325:
1326: // 19: aload %4
1327: il.append(mp.createVariableLoad(receiverParameterName));
1328: // 21: invokevirtual biz.hammurapi.sql.SQLProcessor.project (Ljava/lang/String;Lcom/pavelvlasov/sql/Parameterizer;Lcom/pavelvlasov/sql/Projector;Ljava/util/Collection;)Ljava/util/Collection; (72)
1329: il.append(c.createInvoke(SQLProcessor.class.getName(),
1330: "java.util.Collection project(java.lang.String,"
1331: + Parameterizer.class.getName() + ","
1332: + Projector.class.getName()
1333: + ",java.util.Collection)", null,
1334: Constants.INVOKEVIRTUAL));
1335: // 24: areturn
1336: il.append(new ARETURN());
1337:
1338: mp.setAttribute("element-type", getInterfaceName(packageName));
1339: mp
1340: .addMethod(
1341: il,
1342: null,
1343: "Executes query, populates collection with elements of type "
1344: + getInterfaceName(packageName)
1345: + " and returns populated collection. "
1346: + "If converter is not null then elements will be results of conversion. "
1347: + getDescription());
1348: }
1349:
1350: private void generateGetFirstColumn(String packageName, Class c)
1351: throws GenerationException {
1352: ColumnDescriptor cd = (ColumnDescriptor) columnDescriptors
1353: .iterator().next();
1354: String primitiveTypeName = ParameterDescriptor.toPrimitive(cd
1355: .getType());
1356: String returnType = getColumnType(cd,
1357: cd.isNullable()
1358: || !ParameterDescriptor.mapsToPrimitive(cd
1359: .getType()) ? cd.getType()
1360: : primitiveTypeName);
1361: if (returnType == null) {
1362: return;
1363: }
1364:
1365: MethodPrototype mp = new MethodPrototype(c,
1366: getEngineMethodsVisibility() + " " + returnType
1367: + " get" + name + "() throws "
1368: + SQLException.class.getName(),
1369: parameterDescriptors);
1370:
1371: InstructionList il = new InstructionList();
1372:
1373: // 0 0:aload_0
1374: il.append(new ALOAD(0));
1375: // 1 1:getfield #204 <Field SQLProcessor _processor>
1376: il.append(c.createGetField("_processor"));
1377: // 2 4:ldc1 #250 <String "SELECT COUNT(*) AS CNT FROM REPOSITORY WHERE NAME=?">
1378: il.append(new LDC(c.getClassGen().getConstantPool().addString(
1379: getSql())));
1380:
1381: if (parameterDescriptors.isEmpty()) {
1382: il.append(new ACONST_NULL());
1383: } else {
1384: // 3 6:new #252 <Class CheckRepositoryNameParameterizer_112>
1385: // 4 9:dup
1386: String parameterizerClass = generateParameterizerName(c
1387: .getClassGen().getClassName());
1388: il.append(c.getInstructionFactory().createNew(
1389: parameterizerClass));
1390: il.append(new DUP());
1391: Iterator it = parameterDescriptors.iterator();
1392: while (it.hasNext()) {
1393: il.append(mp.createVariableLoad(((Parameter) it.next())
1394: .getName()));
1395: }
1396: il.append(c.createInvoke(parameterizerClass,
1397: "void <init>()", parameterDescriptors,
1398: Constants.INVOKESPECIAL));
1399: }
1400:
1401: // 7 14:invokevirtual #257 <Method int SQLProcessor.projectSingleInt(String, Parameterizer)>
1402: String projectMethod = SQLProcessor
1403: .findProjectSingleMethodName(returnType);
1404: if (projectMethod == null) {
1405: il.append(c.createInvoke(SQLProcessor.class.getName(),
1406: "java.lang.Object projectSingleObject(java.lang.String,"
1407: + Parameterizer.class.getName() + ")",
1408: null, Constants.INVOKEVIRTUAL));
1409: il.append(c.getInstructionFactory().createCheckCast(
1410: (ReferenceType) ClassGeneratorBase
1411: .java2BcelType(returnType)));
1412: } else {
1413: il.append(c.createInvoke(SQLProcessor.class.getName(),
1414: returnType + " " + projectMethod
1415: + "(java.lang.String,"
1416: + Parameterizer.class.getName() + ")",
1417: null, Constants.INVOKEVIRTUAL));
1418: }
1419:
1420: // 8 17:ireturn
1421: il.append(mp.createReturn());
1422:
1423: mp
1424: .addMethod(
1425: il,
1426: null,
1427: "Executes query and returns value of the first (the only) column in the first row. "
1428: + getDescription());
1429: }
1430:
1431: private void generateGetSingleObject(String packageName, Class c)
1432: throws GenerationException {
1433: MethodPrototype mp = new MethodPrototype(c,
1434: getEngineMethodsVisibility() + " "
1435: + getInterfaceName(packageName) + " get" + name
1436: + "() throws " + SQLException.class.getName(),
1437: parameterDescriptors);
1438: // Interface getXXX(parameters)
1439: InstructionList il = new InstructionList();
1440:
1441: // 0: aload_0
1442: il.append(new ALOAD(0));
1443: // 1: getfield org.jincarnate.util.SampleClass.processor Lcom/pavelvlasov/sql/SQLProcessor; (52)
1444: il.append(c.createGetField("_processor"));
1445: // 4: ldc "ABC" (61)
1446: il.append(new LDC(c.getClassGen().getConstantPool().addString(
1447: getSql())));
1448: InstructionFactory iFactory = c.getInstructionFactory();
1449: if (parameterDescriptors.isEmpty()) {
1450: il.append(new ACONST_NULL());
1451: } else {
1452: // 6: new <org.jincarnate.util.SampleClass$PackageQueryParameterizer> (63)
1453: String parameterizerClass = generateParameterizerName(c
1454: .getClassGen().getClassName());
1455: il.append(iFactory.createNew(parameterizerClass));
1456: // 9: dup
1457: il.append(new DUP());
1458: // 10: aload_1
1459: // 11: iload_2
1460: // 12: iload_3
1461: Iterator it = parameterDescriptors.iterator();
1462: while (it.hasNext()) {
1463: il.append(mp.createVariableLoad(((Parameter) it.next())
1464: .getName()));
1465: }
1466: // 13: invokespecial org.jincarnate.util.SampleClass$PackageQueryParameterizer.<init> (Ljava/lang/String;SI)V (66)
1467: il.append(c.createInvoke(parameterizerClass,
1468: "void <init>()", parameterDescriptors,
1469: Constants.INVOKESPECIAL));
1470: }
1471:
1472: // 4 7:new #48 <Class SmartProjector>
1473: String smartProjectorName = SmartProjector.class.getName();
1474: il.append(iFactory.createNew(smartProjectorName));
1475: // 5 10:dup
1476: il.append(new DUP());
1477: // 6 11:getstatic #24 <Field Class IMPL_CLASS>
1478: il.append(c.createGetField(getImplClassFieldName(packageName)));
1479: // 7 14:invokespecial #51 <Method void SmartProjector(Class)>
1480: il.append(c.createInvoke(smartProjectorName,
1481: "void <init>(java.lang.Class)", null,
1482: Constants.INVOKESPECIAL));
1483:
1484: // 19: invokevirtual biz.hammurapi.sql.SQLProcessor.projectSingleObject (Ljava/lang/String;Lcom/pavelvlasov/sql/Parameterizer;Lcom/pavelvlasov/sql/Projector;)Ljava/lang/Object; (72)
1485: il.append(c.createInvoke(SQLProcessor.class.getName(),
1486: "java.lang.Object projectSingleObject(java.lang.String,"
1487: + Parameterizer.class.getName() + ","
1488: + Projector.class.getName() + ")", null,
1489: Constants.INVOKEVIRTUAL));
1490: // 22: checkcast <java.net.URL> (74)
1491: il.append(iFactory
1492: .createCheckCast((ReferenceType) ClassGeneratorBase
1493: .java2BcelType(getInterfaceName(packageName))));
1494: // 25: areturn
1495: il.append(new ARETURN());
1496:
1497: mp.addMethod(il, null,
1498: "Executes query and returns single object. "
1499: + getDescription());
1500: }
1501:
1502: private void generateGetSingleSubclassObject(String packageName,
1503: Class c) throws GenerationException {
1504: Collection parameters = new ArrayList(parameterDescriptors);
1505: final String targetClassParameterName = uniquifyParameter(
1506: parameters, "targetClass");
1507: parameters.add(new Parameter() {
1508: public String getName() {
1509: return targetClassParameterName;
1510: }
1511:
1512: public String getType() {
1513: return "java.lang.Class";
1514: }
1515: });
1516:
1517: MethodPrototype mp = new MethodPrototype(c,
1518: getEngineMethodsVisibility() + " "
1519: + getInterfaceName(packageName) + " get" + name
1520: + "() throws " + SQLException.class.getName(),
1521: parameters);
1522: // Interface getXXX(parameters)
1523: InstructionList il = new InstructionList();
1524:
1525: // 0: aload_0
1526: il.append(new ALOAD(0));
1527: // 1: getfield org.jincarnate.util.SampleClass.processor Lcom/pavelvlasov/sql/SQLProcessor; (52)
1528: il.append(c.createGetField("_processor"));
1529: // 4: ldc "ABC" (61)
1530: il.append(new LDC(c.getClassGen().getConstantPool().addString(
1531: getSql())));
1532: InstructionFactory iFactory = c.getInstructionFactory();
1533: if (parameterDescriptors.isEmpty()) {
1534: il.append(new ACONST_NULL());
1535: } else {
1536: // 6: new <org.jincarnate.util.SampleClass$PackageQueryParameterizer> (63)
1537: String parameterizerClass = generateParameterizerName(c
1538: .getClassGen().getClassName());
1539: il.append(iFactory.createNew(parameterizerClass));
1540: // 9: dup
1541: il.append(new DUP());
1542: // 10: aload_1
1543: // 11: iload_2
1544: // 12: iload_3
1545: Iterator it = parameterDescriptors.iterator();
1546: while (it.hasNext()) {
1547: il.append(mp.createVariableLoad(((Parameter) it.next())
1548: .getName()));
1549: }
1550: // 13: invokespecial org.jincarnate.util.SampleClass$PackageQueryParameterizer.<init> (Ljava/lang/String;SI)V (66)
1551: il.append(c.createInvoke(parameterizerClass,
1552: "void <init>()", parameterDescriptors,
1553: Constants.INVOKESPECIAL));
1554: }
1555:
1556: // 4 7:new #48 <Class SmartProjector>
1557: String smartProjectorName = SmartProjector.class.getName();
1558: il.append(iFactory.createNew(smartProjectorName));
1559: // 5 10:dup
1560: il.append(new DUP());
1561: // 6 11:getstatic #24 <Field Class IMPL_CLASS>
1562: il.append(c.createGetField(getImplClassFieldName(packageName)));
1563: // 7 14:aload_1
1564: il.append(mp.createVariableLoad(targetClassParameterName));
1565: // 8 15:aconst_null
1566: il.append(new ACONST_NULL());
1567: // 7 14:invokespecial #51 <Method void SmartProjector(Class)>
1568: il.append(c.createInvoke(smartProjectorName,
1569: "void <init>(java.lang.Class,java.lang.Class,"
1570: + Converter.class.getName() + ")", null,
1571: Constants.INVOKESPECIAL));
1572:
1573: // 19: invokevirtual biz.hammurapi.sql.SQLProcessor.projectSingleObject (Ljava/lang/String;Lcom/pavelvlasov/sql/Parameterizer;Lcom/pavelvlasov/sql/Projector;)Ljava/lang/Object; (72)
1574: il.append(c.createInvoke(SQLProcessor.class.getName(),
1575: "java.lang.Object projectSingleObject(java.lang.String,"
1576: + Parameterizer.class.getName() + ","
1577: + Projector.class.getName() + ")", null,
1578: Constants.INVOKEVIRTUAL));
1579: // 22: checkcast <java.net.URL> (74)
1580: il.append(iFactory
1581: .createCheckCast((ReferenceType) ClassGeneratorBase
1582: .java2BcelType(getInterfaceName(packageName))));
1583: // 25: areturn
1584: il.append(new ARETURN());
1585:
1586: mp
1587: .addMethod(
1588: il,
1589: null,
1590: "Executes query and returns single object of target class type. "
1591: + "Target class must be return type compatible. "
1592: + getDescription());
1593: }
1594:
1595: /**
1596: * @param collection
1597: */
1598: public static void dumpCollection(String name, Set collection) {
1599: System.out.println(name);
1600: Iterator omit = collection.iterator();
1601: while (omit.hasNext()) {
1602: System.out.println("\t" + omit.next());
1603: }
1604: }
1605:
1606: protected void generateEngineMethods(String packageName, Class c)
1607: throws GenerationException {
1608: if (isSingleRow) {
1609: if (isToBeGenerated()) {
1610: generateGetSingleObject(packageName, c);
1611: generateGetSingleSubclassObject(packageName, c);
1612: } else {
1613: generateGetFirstColumn(packageName, c);
1614: }
1615: } else {
1616: if (isToBeGenerated()) {
1617: generateGetDatabaseBackedCollection(packageName, c);
1618: generateGetDatabaseBackedCollectionConverted(
1619: packageName, c);
1620: generateGetDatabaseBackedCollectionTargeted(
1621: packageName, c);
1622:
1623: generateGetCollection(packageName, c);
1624: generateGetCollectionConverted(packageName, c);
1625: generateGetCollectionTargeted(packageName, c);
1626: } else {
1627: generateGetDatabaseBackedCollectionFC(packageName, c);
1628: generateGetDatabaseBackedCollectionConvertedFC(
1629: packageName, c);
1630: generateGetDatabaseBackedCollectionTargetedFC(
1631: packageName, c);
1632:
1633: generateGetCollectionFC(packageName, c);
1634: generateGetCollectionConvertedFC(packageName, c);
1635: generateGetCollectionTargetedFC(packageName, c);
1636: }
1637:
1638: generateToRowProcessor(packageName, c);
1639: }
1640: }
1641:
1642: public static void main(String[] args) throws Exception {
1643: SQLProcessor processor = new SQLProcessor(
1644: new HypersonicInMemoryDataSource(
1645: "com/pavelvlasov/sql/java/util/Jsel.sql"), null);
1646:
1647: String sql = "SELECT * FROM COMPILATION_UNIT";
1648: // C " +
1649: // "WHERE REPOSITORY=? AND C.STORE_LEVEL=? AND " +
1650: // "EXISTS(SELECT * FROM COMPILATION_UNIT_SCAN S " +
1651: // "WHERE S.COMPILATION_UNIT_ID=C.ID AND " +
1652: // "S.REPOSITORY=C.REPOSITORY AND S.SCAN_ID=?)";
1653:
1654: NamedQuery nq = new NamedQuery("PackageQuery",
1655: "Retrieves package names", true, sql, processor,
1656: new DefaultGenerationPolicy(), false, true);
1657: nq.generate("a.b.c", new Consumer() {
1658: public void consume(JavaClass javaClass)
1659: throws GenerationException {
1660: try {
1661: javaClass.dump(new File("generated\\"
1662: + javaClass.getClassName().replace('.',
1663: '\\') + ".class"));
1664: } catch (IOException e) {
1665: throw new GenerationException(e);
1666: }
1667: }
1668:
1669: private GenerationListener gl = new GenerationListener() {
1670:
1671: public void onClass(ClassGen classGen,
1672: String description) {
1673: System.out.println(classGen.getClassName() + " "
1674: + description);
1675: }
1676:
1677: public void onMethod(String className,
1678: String signature, String description,
1679: Properties attributes) {
1680: System.out.println(signature + " " + description);
1681: }
1682:
1683: public void onField(String className,
1684: String declaration, String description,
1685: Properties attributes) {
1686: System.out.println(declaration + " " + description);
1687: }
1688: };
1689:
1690: public GenerationListener getListener() {
1691: return gl;
1692: }
1693:
1694: }, null);
1695:
1696: // PackageQueryFactory factory=new PackageQueryFactory(processor);
1697: // System.out.println(factory.getPackageQuery("ald", (short) 3, 22).size());
1698: }
1699:
1700: protected Collection getInterfaceProperties() {
1701: return columnDescriptors;
1702: }
1703: }
|