001: /*
002: * sqlc 1
003: * SQL Compiler
004: * Copyright (C) 2003 Hammurapi Group
005: *
006: * This program is free software; you can redistribute it and/or
007: * modify it under the terms of the GNU Lesser General Public
008: * License as published by the Free Software Foundation; either
009: * version 2 of the License, or (at your option) any later version.
010: *
011: * This program is distributed in the hope that it will be useful,
012: * but WITHOUT ANY WARRANTY; without even the implied warranty of
013: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
014: * Lesser General Public License for more details.
015: *
016: * You should have received a copy of the GNU Lesser General Public
017: * License along with this library; if not, write to the Free Software
018: * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
019: *
020: * URL: http://www.hammurapi.biz/products/sqlc/index.html
021: * e-Mail: support@hammurapi.biz
022: */
023: package biz.hammurapi.sqlc;
024:
025: import java.sql.SQLException;
026: import java.util.ArrayList;
027: import java.util.Collection;
028: import java.util.Iterator;
029:
030: import org.apache.tools.ant.BuildException;
031:
032: import biz.hammurapi.codegen.GenerationException;
033: import biz.hammurapi.sql.SQLProcessor;
034: import biz.hammurapi.sql.metadata.GenerationPolicy;
035:
036: /**
037: * @ant.element name="query"
038: * @author Pavel Vlasov
039: * @version $Revision: 1.6 $
040: */
041: public class QueryEntry extends StatementEntry implements ColumnHolder {
042: private boolean isSingleRow;
043: private boolean generateMutators = true;
044: private boolean isSmart = true;
045: private String smartBase;
046:
047: /**
048: * @ant.ignore
049: * @return Returns the smartBase.
050: */
051: String getSmartBase() {
052: return smartBase == null ? task.getSmartBase() : smartBase;
053: }
054:
055: /**
056: * Base class (fully qualified name) for generated smart implementation. Default is biz.hammurapi.sql.DatabaseObject
057: * The base class is supposed to have same constructors and methods as DatabaseObject. The idea is
058: * to subclass DatabaseObject to introduce additional qualities like audit, metrics, security, ... whithout
059: * changing class' contract. Applies only if isSmart==true. If not set explicitly the value is inherited from the task.
060: * @ant.non-required
061: * @param smartBase The smartBase to set.
062: */
063: public void setSmartBase(String smartBase) {
064: this .smartBase = smartBase;
065: }
066:
067: /**
068: * Forces generation of smart interface implementation. Default is true.
069: * @ant.non-required
070: * @param isSmart
071: */
072: public void setSmart(boolean isSmart) {
073: this .isSmart = isSmart;
074: }
075:
076: /**
077: * If 'true' (default) then mutators (setters) are generated along with
078: * accessors (getters) in row interface.
079: * @ant.non-required
080: * @param generateMutator
081: */
082: public void setGenerateMutators(boolean generateMutators) {
083: this .generateMutators = generateMutators;
084: }
085:
086: /**
087: * Set it to true if query always yield a single row, of if you are interesed in
088: * only the first row from returned resultset.
089: * @ant.non-required
090: * @param isSingleRow
091: */
092: public void setSingleRow(boolean isSingleRow) {
093: this .isSingleRow = isSingleRow;
094: }
095:
096: /**
097: * @param processor
098: * @return
099: * @throws SQLException
100: * @throws GenerationException
101: */
102: NamedStatement getStatement(SQLProcessor processor,
103: GenerationPolicy generationPolicy) throws SQLException,
104: GenerationException {
105:
106: NamedQuery ret = new NamedQuery(name, description, isSingleRow,
107: sql, processor, generationPolicy,
108: hasNullableParameters, generateMutators);
109:
110: ret
111: .setMode(isSmart ? NamedInterfaceGeneratingStatement.MODE_SMART
112: : NamedInterfaceGeneratingStatement.MODE_SIMPLE);
113:
114: String sb = getSmartBase();
115: if (sb != null) {
116: ret.setSmartBaseName(sb);
117: }
118:
119: Iterator it = colTypes.iterator();
120: while (it.hasNext()) {
121: ColumnType ct = (ColumnType) it.next();
122: ret.setColumnType(ct.getName(), ct.getType());
123: }
124:
125: if (parameters != null) {
126: ret.setParameters(parameters);
127: }
128:
129: setParamTypes(ret);
130:
131: ret.setUseSqlTypes(getUseSqlTypes());
132: return ret;
133: }
134:
135: /**
136: * Column type. Overrides type reported by database.
137: * @ant.non-required
138: * @param paramType
139: */
140: public void addConfiguredColumn(ColumnType colType) {
141: if (colType.getName() == null) {
142: throw new BuildException(
143: "Column name is not set for column type");
144: }
145: if (!colType.isSkip() && colType.getType() == null) {
146: throw new BuildException(
147: "Column type is not set for column "
148: + colType.getName());
149: }
150: colTypes.add(colType);
151: }
152:
153: private Collection colTypes = new ArrayList();
154:
155: public Collection getColTypes() {
156: return colTypes;
157: }
158: }
|