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: * @author Pavel Vlasov
038: * @version $Revision: 1.4 $
039: */
040: public abstract class StatementEntry {
041:
042: /**
043: * @param processor
044: * @return
045: */
046: abstract NamedStatement getStatement(SQLProcessor processor,
047: GenerationPolicy generationPolicy) throws SQLException,
048: GenerationException;
049:
050: protected String sql = "";
051: protected boolean hasNullableParameters;
052: protected String name;
053: protected String description;
054: private Collection paramTypes = new ArrayList();
055:
056: /**
057: * Set it to true if query contains primitive type parameters which can be 'NULL' and
058: * engine will be generated with primitive type wrapper classes as parameters. E.g.
059: * java.lang.Integer instead of int.
060: * @ant.non-required
061: * @param hasNullableParameters
062: */
063: public void setHasNullableParameters(boolean hasNullableParameters) {
064: this .hasNullableParameters = hasNullableParameters;
065: }
066:
067: protected StatementCompilerTask task;
068:
069: void setTask(StatementCompilerTask task) {
070: this .task = task;
071: }
072:
073: /**
074: * SQL query per-se.
075: * @ant.required
076: * @param sql
077: */
078: public void addText(String sql) {
079: this .sql += sql;
080: }
081:
082: /**
083: * @ant.ignore
084: * @param sql
085: */
086: public void setStatementText(String sql) {
087: this .sql = sql;
088: }
089:
090: protected String parameters;
091:
092: /**
093: * Sets parameter names and types. Useful with not fully compilian JDBC drivers.
094: * Comma separated list of parameters in Java format, e.g. int a, long b, java.lang.String c.
095: * Type is optional. Class names must be fully qualified. Specifications can be skipped, e.g. int a,,java.lang.String c
096: * Type can include SQL type as defined in java.sql.Types. E.g. int:INTEGER, both sides are optional. Nullability can be
097: * specified using 'nullable' and 'not nullable' modifiers.
098: * Full types grammar looks like: <pre>
099: * parameters = parameter? (, parameter)*
100: * parameter = name | (typeDefinition name ("nullable" | "not nullable")?)
101: * typeDefinition = javaType | (javaType? ":" sqlType?)
102: * </pre>
103: * An alternative way to override parameter types is to use nested parameter element.
104: * Nested elements take precedence over parameters attribute.
105: * @ant.non-required
106: */
107: public void setParameters(String parameters) {
108: this .parameters = parameters;
109: }
110:
111: /**
112: * Statement name
113: * @ant.required
114: * @param name
115: */
116: public void setName(String name) {
117: this .name = name;
118: }
119:
120: /**
121: * Statement description
122: * @ant.non-required
123: * @param description
124: */
125: public void setDescription(String description) {
126: this .description = description;
127: }
128:
129: /**
130: * Parameter type. Overrides type reported by database.
131: * @ant.non-required
132: * @param paramType
133: */
134: public void addConfiguredParameter(ParamType paramType) {
135: if (paramType.getPosition() < 1) {
136: throw new BuildException(
137: "Invalid position in parameter type: "
138: + paramType.getPosition());
139: }
140: if (paramType.getType() == null) {
141: throw new BuildException(
142: "Parameter type is not set for parameter "
143: + paramType.getPosition());
144: }
145: paramTypes.add(paramType);
146: }
147:
148: public Collection getParamTypes() {
149: return paramTypes;
150: }
151:
152: protected void setParamTypes(NamedStatement ns)
153: throws GenerationException {
154: Iterator it = paramTypes.iterator();
155: while (it.hasNext()) {
156: ParamType pt = (ParamType) it.next();
157: ns.setParamType(pt.getPosition(), pt.getType());
158: }
159: }
160:
161: private Boolean useSqlTypes;
162:
163: /**
164: * If true then generated classes will use setObject(int, Object, int) method
165: * instead of setObject(int, Object) to set parameters of object type.
166: * Inherits value from task. Default value is false.
167: * @ant.non-required
168: * @param useSqlTypes
169: */
170: public void setUseSqlTypes(boolean useSqlTypes) {
171: this .useSqlTypes = useSqlTypes ? Boolean.TRUE : Boolean.FALSE;
172: }
173:
174: /**
175: * @return
176: */
177: protected boolean getUseSqlTypes() {
178: if (task == null) {
179: throw new BuildException("Task is null");
180: }
181:
182: if (useSqlTypes == null) {
183: return task.getUseSqlTypes() == null ? false : task
184: .getUseSqlTypes().booleanValue();
185: }
186:
187: return useSqlTypes.booleanValue();
188: }
189: }
|