Coverage Report

Coverage Report - org.apache.torque.engine.database.transform.SQLToAppData

Classes in this File

Line Coverage

Branch Coverage

Complexity

SQLToAppData

0/224

0/122

5.267

 package org.apache.torque.engine.database.transform;
 
 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE
  * file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file
  * to you 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.
  */
 
 import java.io.BufferedReader;
 import java.io.FileReader;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
 
 import org.apache.torque.engine.database.model.Column;
 import org.apache.torque.engine.database.model.Database;
 import org.apache.torque.engine.database.model.ForeignKey;
 import org.apache.torque.engine.database.model.IDMethod;
 import org.apache.torque.engine.database.model.Table;
 import org.apache.torque.engine.sql.ParseException;
 import org.apache.torque.engine.sql.SQLScanner;
 import org.apache.torque.engine.sql.Token;
 
 /**
  * A Class that converts an sql input file to a Database structure. The class makes use of SQL Scanner to get sql tokens
  * and the parses these to create the Database class. SQLToAppData is in effect a simplified sql parser.
  * 
  * @author <a href="mailto:leon@opticode.co.za">Leon Messerschmidt</a>
  * @author <a href="mailto:jon@latchkey.com">Jon S. Stevens</a>
  * @version $Id: SQLToAppData.java,v 1.1 2007-10-21 07:57:26 abyrne Exp $
  */
 public class SQLToAppData {
     private String sqlFile;
     private List tokens;
     private Token token;
     private Database appDataDB;
     private int count;
     private String databaseType;
 
     /**
      * Create a new class with an input Reader
      * 
      * @param sqlFile
      *            the sql file
      */
     public SQLToAppData(String sqlFile) {
         this.sqlFile = sqlFile;
     }
 
     /**
      * Create a new class with an input Reader. This ctor is not used but putting here in the event db.props properties
      * are found to be useful converting sql to xml, the infrastructure will exist
      * 
      * @param sqlFile
      *            the sql file
      * @param databaseType
      */
     public SQLToAppData(String sqlFile, String databaseType) {
         this.sqlFile = sqlFile;
         this.databaseType = databaseType;
     }
 
     /**
      * Get the current input sql file
      * 
      * @return the sql file
      */
     public String getSqlFile() {
         return sqlFile;
     }
 
     /**
      * Set the current input sql file
      * 
      * @param sqlFile
      *            the sql file
      */
     public void setSqlFile(String sqlFile) {
         this.sqlFile = sqlFile;
     }
 
     /**
      * Move to the next token.
      * 
      * @throws ParseException
      *             if there is no more tokens available.
      */
     private void next() throws ParseException {
         if (count < tokens.size()) {
             token = (Token) tokens.get(count++);
         } else {
             throw new ParseException("No More Tokens");
         }
     }
 
     /**
      * Creates an error condition and adds the line and column number of the current token to the error message.
      * 
      * @param name
      *            name of the error
      * @throws ParseException
      */
     private void err(String name) throws ParseException {
         throw new ParseException(name + " at [ line: " + token.getLine() + " col: " + token.getCol() + " ]");
     }
 
     /**
      * Check if there is more tokens available for parsing.
      * 
      * @return true if there are more tokens available
      */
     private boolean hasTokens() {
         return count < tokens.size();
     }
 
     /**
      * Parses a CREATE TABLE FOO command.
      * 
      * @throws ParseException
      */
     private void create() throws ParseException {
         next();
         if (token.getStr().toUpperCase().equals("TABLE")) {
             createTable();
         }
     }
 
     /**
      * Parses a CREATE TABLE sql command
      * 
      * @throws ParseException
      *             error parsing the input file
      */
     private void createTable() throws ParseException {
         next();
         String tableName = token.getStr(); // name of the table
         next();
         if (!token.getStr().equals("(")) {
             err("( expected");
         }
         next();
 
         Table tbl = new Table(tableName);
         // tbl.setIdMethod("none");
         while (!token.getStr().equals(";")) {
             createTableColumn(tbl);
         }
 
         if (tbl.getPrimaryKey().size() == 1) {
             tbl.setIdMethod(IDMethod.ID_BROKER);
         } else {
             tbl.setIdMethod(IDMethod.NO_ID_METHOD);
         }
         appDataDB.addTable(tbl);
     }
 
     /**
      * Parses column information between the braces of a CREATE TABLE () sql statement.
      * 
      * @throws ParseException
      *             error parsing the input file
      */
     private void createTableColumn(Table tbl) throws ParseException {
         // The token should be the first item
         // which is the name of the column or
         // PRIMARY/FOREIGN/UNIQUE
         if (token.getStr().equals(",")) {
             next();
         }
 
         if (token.getStr().toUpperCase().equals("PRIMARY")) {
             createTableColumnPrimary(tbl);
         } else if (token.getStr().toUpperCase().equals("FOREIGN")) {
             createTableColumnForeign(tbl);
         } else if (token.getStr().toUpperCase().equals("UNIQUE")) {
             createTableColumnUnique(tbl);
         } else {
             createTableColumnData(tbl);
         }
     }
 
     /**
      * Parses PRIMARY KEY (FOO,BAR) statement
      * 
      * @throws ParseException
      *             error parsing the input file
      */
     private void createTableColumnPrimary(Table tbl) throws ParseException {
         next();
         if (!token.getStr().toUpperCase().equals("KEY")) {
             err("KEY expected");
         }
         next();
         if (!token.getStr().toUpperCase().equals("(")) {
             err("( expected");
         }
         next();
 
         String colName = token.getStr();
         Column c = tbl.getColumn(colName);
         if (c == null) {
             err("Invalid column name: " + colName);
         }
         c.setPrimaryKey(true);
         next();
         while (token.getStr().equals(",")) {
             next();
             colName = token.getStr();
             c = tbl.getColumn(colName);
             if (c == null) {
                 err("Invalid column name: " + colName);
             }
             c.setPrimaryKey(true);
             next();
         }
 
         if (!token.getStr().toUpperCase().equals(")")) {
             err(") expected");
         }
         next(); // skip the )
     }
 
     /**
      * Parses UNIQUE (NAME,FOO,BAR) statement
      * 
      * @throws ParseException
      *             error parsing the input file
      */
     private void createTableColumnUnique(Table tbl) throws ParseException {
         next();
         if (!token.getStr().toUpperCase().equals("(")) {
             err("( expected");
         }
         next();
         while (!token.getStr().equals(")")) {
             if (!token.getStr().equals(",")) {
                 String colName = token.getStr();
                 Column c = tbl.getColumn(colName);
                 if (c == null) {
                     err("Invalid column name: " + colName);
                 }
                 c.setUnique(true);
             }
             next();
         }
         if (!token.getStr().toUpperCase().equals(")")) {
             err(") expected got: " + token.getStr());
         }
 
         next(); // skip the )
     }
 
     /**
      * Parses FOREIGN KEY (BAR) REFERENCES TABLE (BAR) statement
      * 
      * @throws ParseException
      *             error parsing the input file
      */
     private void createTableColumnForeign(Table tbl) throws ParseException {
         next();
         if (!token.getStr().toUpperCase().equals("KEY")) {
             err("KEY expected");
         }
         next();
         if (!token.getStr().toUpperCase().equals("(")) {
             err("( expected");
         }
         next();
 
         ForeignKey fk = new ForeignKey();
         List localColumns = new ArrayList();
         tbl.addForeignKey(fk);
 
         String colName = token.getStr();
         localColumns.add(colName);
         next();
         while (token.getStr().equals(",")) {
             next();
             colName = token.getStr();
             localColumns.add(colName);
             next();
         }
         if (!token.getStr().toUpperCase().equals(")")) {
             err(") expected");
         }
 
         next();
 
         if (!token.getStr().toUpperCase().equals("REFERENCES")) {
             err("REFERENCES expected");
         }
 
         next();
 
         fk.setForeignTableName(token.getStr());
 
         next();
 
         if (token.getStr().toUpperCase().equals("(")) {
             next();
             int i = 0;
             fk.addReference((String) localColumns.get(i++), token.getStr());
             next();
             while (token.getStr().equals(",")) {
                 next();
                 fk.addReference((String) localColumns.get(i++), token.getStr());
                 next();
             }
             if (!token.getStr().toUpperCase().equals(")")) {
                 err(") expected");
             }
             next();
         }
     }
 
     /**
      * Parse the data definition of the column statement.
      * 
      * @throws ParseException
      *             error parsing the input file
      */
     private void createTableColumnData(Table tbl) throws ParseException {
         String columnSize = null;
         String columnPrecision = null;
         String columnDefault = null;
         boolean inEnum = false;
 
         String columnName = token.getStr();
         next();
         String columnType = token.getStr();
 
         if (columnName.equals(")") && columnType.equals(";")) {
             return;
         }
 
         next();
 
         // special case for MySQL ENUM's which are stupid anyway
         // and not properly handled by Torque.
         if (columnType.toUpperCase().equals("ENUM")) {
             inEnum = true;
             next(); // skip (
             while (!token.getStr().equals(")")) {
                 // skip until )
                 next();
             }
             while (!token.getStr().equals(",")) {
                 if (token.getStr().toUpperCase().equals("DEFAULT")) {
                     next();
                     if (token.getStr().equals("'")) {
                         next();
                     }
                     columnDefault = token.getStr();
                     next();
                     if (token.getStr().equals("'")) {
                         next();
                     }
                 }
                 // skip until ,
                 next();
             }
             next(); // skip ,
             columnType = "VARCHAR";
         } else if (token.getStr().toUpperCase().equals("(")) {
             next();
             columnSize = token.getStr();
             next();
             if (token.getStr().equals(",")) {
                 next();
                 columnPrecision = token.getStr();
                 next();
             }
 
             if (!token.getStr().equals(")")) {
                 err(") expected");
             }
             next();
         }
 
         Column col = new Column(columnName);
         if (columnPrecision != null) {
             columnSize = columnSize + columnPrecision;
         }
         col.setTypeFromString(columnType, columnSize);
         tbl.addColumn(col);
 
         if (inEnum) {
             col.setNotNull(true);
             if (columnDefault != null) {
                 col.setDefaultValue(columnDefault);
             }
         } else {
             while (!token.getStr().equals(",") && !token.getStr().equals(")")) {
                 if (token.getStr().toUpperCase().equals("NOT")) {
                     next();
                     if (!token.getStr().toUpperCase().equals("NULL")) {
                         err("NULL expected after NOT");
                     }
                     col.setNotNull(true);
                     next();
                 } else if (token.getStr().toUpperCase().equals("PRIMARY")) {
                     next();
                     if (!token.getStr().toUpperCase().equals("KEY")) {
                         err("KEY expected after PRIMARY");
                     }
                     col.setPrimaryKey(true);
                     next();
                 } else if (token.getStr().toUpperCase().equals("UNIQUE")) {
                     col.setUnique(true);
                     next();
                 } else if (token.getStr().toUpperCase().equals("NULL")) {
                     col.setNotNull(false);
                     next();
                 } else if (token.getStr().toUpperCase().equals("AUTO_INCREMENT")) {
                     col.setAutoIncrement(true);
                     next();
                 } else if (token.getStr().toUpperCase().equals("DEFAULT")) {
                     next();
                     if (token.getStr().equals("'")) {
                         next();
                     }
                     col.setDefaultValue(token.getStr());
                     next();
                     if (token.getStr().equals("'")) {
                         next();
                     }
                 } else {
                     StringBuffer line = new StringBuffer();
                     for (Iterator tokenIt = tokens.iterator(); tokenIt.hasNext();) {
                         line.append(tokenIt.next());
                         if (tokenIt.hasNext()) {
                             line.append(" ");
                         }
                     }
                     throw new ParseException("Error parsing line " + line + " : Unknown token Nr. " + count + " : "
                             + token);
                 }
             }
             next(); // eat the ,
         }
     }
 
     /**
      * Execute the parser.
      * 
      * @throws IOException
      *             If an I/O error occurs
      * @throws ParseException
      *             error parsing the input file
      */
     public Database execute() throws IOException, ParseException {
         count = 0;
         appDataDB = new Database(databaseType);
 
         FileReader fr = new FileReader(sqlFile);
         BufferedReader br = new BufferedReader(fr);
         SQLScanner scanner = new SQLScanner(br);
 
         tokens = scanner.scan();
 
         br.close();
 
         while (hasTokens()) {
             if (token == null) {
                 next();
             }
 
             if (token.getStr().toUpperCase().equals("CREATE")) {
                 create();
             }
             if (hasTokens()) {
                 next();
             }
         }
         return appDataDB;
     }
 }

1		package org.apache.torque.engine.database.transform;
2
3		/*
4		* Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE
5		* file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file
6		* to you under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the
7		* License. You may obtain a copy of the License at
8		*
9		* http://www.apache.org/licenses/LICENSE-2.0
10		*
11		* Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
12		* an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
13		* specific language governing permissions and limitations under the License.
14		*/
15
16		import java.io.BufferedReader;
17		import java.io.FileReader;
18		import java.io.IOException;
19		import java.util.ArrayList;
20		import java.util.Iterator;
21		import java.util.List;
22
23		import org.apache.torque.engine.database.model.Column;
24		import org.apache.torque.engine.database.model.Database;
25		import org.apache.torque.engine.database.model.ForeignKey;
26		import org.apache.torque.engine.database.model.IDMethod;
27		import org.apache.torque.engine.database.model.Table;
28		import org.apache.torque.engine.sql.ParseException;
29		import org.apache.torque.engine.sql.SQLScanner;
30		import org.apache.torque.engine.sql.Token;
31
32		/**
33		* A Class that converts an sql input file to a Database structure. The class makes use of SQL Scanner to get sql tokens
34		* and the parses these to create the Database class. SQLToAppData is in effect a simplified sql parser.
35		*
36		* @author <a href="mailto:leon@opticode.co.za">Leon Messerschmidt</a>
37		* @author <a href="mailto:jon@latchkey.com">Jon S. Stevens</a>
38		* @version $Id: SQLToAppData.java,v 1.1 2007-10-21 07:57:26 abyrne Exp $
39		*/
40		public class SQLToAppData {
41		private String sqlFile;
42		private List tokens;
43		private Token token;
44		private Database appDataDB;
45		private int count;
46		private String databaseType;
47
48		/**
49		* Create a new class with an input Reader
50		*
51		* @param sqlFile
52		* the sql file
53		*/
54	0	public SQLToAppData(String sqlFile) {
55	0	this.sqlFile = sqlFile;
56	0	}
57
58		/**
59		* Create a new class with an input Reader. This ctor is not used but putting here in the event db.props properties
60		* are found to be useful converting sql to xml, the infrastructure will exist
61		*
62		* @param sqlFile
63		* the sql file
64		* @param databaseType
65		*/
66	0	public SQLToAppData(String sqlFile, String databaseType) {
67	0	this.sqlFile = sqlFile;
68	0	this.databaseType = databaseType;
69	0	}
70
71		/**
72		* Get the current input sql file
73		*
74		* @return the sql file
75		*/
76		public String getSqlFile() {
77	0	return sqlFile;
78		}
79
80		/**
81		* Set the current input sql file
82		*
83		* @param sqlFile
84		* the sql file
85		*/
86		public void setSqlFile(String sqlFile) {
87	0	this.sqlFile = sqlFile;
88	0	}
89
90		/**
91		* Move to the next token.
92		*
93		* @throws ParseException
94		* if there is no more tokens available.
95		*/
96		private void next() throws ParseException {
97	0	if (count < tokens.size()) {
98	0	token = (Token) tokens.get(count++);
99		} else {
100	0	throw new ParseException("No More Tokens");
101		}
102	0	}
103
104		/**
105		* Creates an error condition and adds the line and column number of the current token to the error message.
106		*
107		* @param name
108		* name of the error
109		* @throws ParseException
110		*/
111		private void err(String name) throws ParseException {
112	0	throw new ParseException(name + " at [ line: " + token.getLine() + " col: " + token.getCol() + " ]");
113		}
114
115		/**
116		* Check if there is more tokens available for parsing.
117		*
118		* @return true if there are more tokens available
119		*/
120		private boolean hasTokens() {
121	0	return count < tokens.size();
122		}
123
124		/**
125		* Parses a CREATE TABLE FOO command.
126		*
127		* @throws ParseException
128		*/
129		private void create() throws ParseException {
130	0	next();
131	0	if (token.getStr().toUpperCase().equals("TABLE")) {
132	0	createTable();
133		}
134	0	}
135
136		/**
137		* Parses a CREATE TABLE sql command
138		*
139		* @throws ParseException
140		* error parsing the input file
141		*/
142		private void createTable() throws ParseException {
143	0	next();
144	0	String tableName = token.getStr(); // name of the table
145	0	next();
146	0	if (!token.getStr().equals("(")) {
147	0	err("( expected");
148		}
149	0	next();
150
151	0	Table tbl = new Table(tableName);
152		// tbl.setIdMethod("none");
153	0	while (!token.getStr().equals(";")) {
154	0	createTableColumn(tbl);
155		}
156
157	0	if (tbl.getPrimaryKey().size() == 1) {
158	0	tbl.setIdMethod(IDMethod.ID_BROKER);
159		} else {
160	0	tbl.setIdMethod(IDMethod.NO_ID_METHOD);
161		}
162	0	appDataDB.addTable(tbl);
163	0	}
164
165		/**
166		* Parses column information between the braces of a CREATE TABLE () sql statement.
167		*
168		* @throws ParseException
169		* error parsing the input file
170		*/
171		private void createTableColumn(Table tbl) throws ParseException {
172		// The token should be the first item
173		// which is the name of the column or
174		// PRIMARY/FOREIGN/UNIQUE
175	0	if (token.getStr().equals(",")) {
176	0	next();
177		}
178
179	0	if (token.getStr().toUpperCase().equals("PRIMARY")) {
180	0	createTableColumnPrimary(tbl);
181	0	} else if (token.getStr().toUpperCase().equals("FOREIGN")) {
182	0	createTableColumnForeign(tbl);
183	0	} else if (token.getStr().toUpperCase().equals("UNIQUE")) {
184	0	createTableColumnUnique(tbl);
185		} else {
186	0	createTableColumnData(tbl);
187		}
188	0	}
189
190		/**
191		* Parses PRIMARY KEY (FOO,BAR) statement
192		*
193		* @throws ParseException
194		* error parsing the input file
195		*/
196		private void createTableColumnPrimary(Table tbl) throws ParseException {
197	0	next();
198	0	if (!token.getStr().toUpperCase().equals("KEY")) {
199	0	err("KEY expected");
200		}
201	0	next();
202	0	if (!token.getStr().toUpperCase().equals("(")) {
203	0	err("( expected");
204		}
205	0	next();
206
207	0	String colName = token.getStr();
208	0	Column c = tbl.getColumn(colName);
209	0	if (c == null) {
210	0	err("Invalid column name: " + colName);
211		}
212	0	c.setPrimaryKey(true);
213	0	next();
214	0	while (token.getStr().equals(",")) {
215	0	next();
216	0	colName = token.getStr();
217	0	c = tbl.getColumn(colName);
218	0	if (c == null) {
219	0	err("Invalid column name: " + colName);
220		}
221	0	c.setPrimaryKey(true);
222	0	next();
223		}
224
225	0	if (!token.getStr().toUpperCase().equals(")")) {
226	0	err(") expected");
227		}
228	0	next(); // skip the )
229	0	}
230
231		/**
232		* Parses UNIQUE (NAME,FOO,BAR) statement
233		*
234		* @throws ParseException
235		* error parsing the input file
236		*/
237		private void createTableColumnUnique(Table tbl) throws ParseException {
238	0	next();
239	0	if (!token.getStr().toUpperCase().equals("(")) {
240	0	err("( expected");
241		}
242	0	next();
243	0	while (!token.getStr().equals(")")) {
244	0	if (!token.getStr().equals(",")) {
245	0	String colName = token.getStr();
246	0	Column c = tbl.getColumn(colName);
247	0	if (c == null) {
248	0	err("Invalid column name: " + colName);
249		}
250	0	c.setUnique(true);
251		}
252	0	next();
253		}
254	0	if (!token.getStr().toUpperCase().equals(")")) {
255	0	err(") expected got: " + token.getStr());
256		}
257
258	0	next(); // skip the )
259	0	}
260
261		/**
262		* Parses FOREIGN KEY (BAR) REFERENCES TABLE (BAR) statement
263		*
264		* @throws ParseException
265		* error parsing the input file
266		*/
267		private void createTableColumnForeign(Table tbl) throws ParseException {
268	0	next();
269	0	if (!token.getStr().toUpperCase().equals("KEY")) {
270	0	err("KEY expected");
271		}
272	0	next();
273	0	if (!token.getStr().toUpperCase().equals("(")) {
274	0	err("( expected");
275		}
276	0	next();
277
278	0	ForeignKey fk = new ForeignKey();
279	0	List localColumns = new ArrayList();
280	0	tbl.addForeignKey(fk);
281
282	0	String colName = token.getStr();
283	0	localColumns.add(colName);
284	0	next();
285	0	while (token.getStr().equals(",")) {
286	0	next();
287	0	colName = token.getStr();
288	0	localColumns.add(colName);
289	0	next();
290		}
291	0	if (!token.getStr().toUpperCase().equals(")")) {
292	0	err(") expected");
293		}
294
295	0	next();
296
297	0	if (!token.getStr().toUpperCase().equals("REFERENCES")) {
298	0	err("REFERENCES expected");
299		}
300
301	0	next();
302
303	0	fk.setForeignTableName(token.getStr());
304
305	0	next();
306
307	0	if (token.getStr().toUpperCase().equals("(")) {
308	0	next();
309	0	int i = 0;
310	0	fk.addReference((String) localColumns.get(i++), token.getStr());
311	0	next();
312	0	while (token.getStr().equals(",")) {
313	0	next();
314	0	fk.addReference((String) localColumns.get(i++), token.getStr());
315	0	next();
316		}
317	0	if (!token.getStr().toUpperCase().equals(")")) {
318	0	err(") expected");
319		}
320	0	next();
321		}
322	0	}
323
324		/**
325		* Parse the data definition of the column statement.
326		*
327		* @throws ParseException
328		* error parsing the input file
329		*/
330		private void createTableColumnData(Table tbl) throws ParseException {
331	0	String columnSize = null;
332	0	String columnPrecision = null;
333	0	String columnDefault = null;
334	0	boolean inEnum = false;
335
336	0	String columnName = token.getStr();
337	0	next();
338	0	String columnType = token.getStr();
339
340	0	if (columnName.equals(")") && columnType.equals(";")) {
341	0	return;
342		}
343
344	0	next();
345
346		// special case for MySQL ENUM's which are stupid anyway
347		// and not properly handled by Torque.
348	0	if (columnType.toUpperCase().equals("ENUM")) {
349	0	inEnum = true;
350	0	next(); // skip (
351	0	while (!token.getStr().equals(")")) {
352		// skip until )
353	0	next();
354		}
355	0	while (!token.getStr().equals(",")) {
356	0	if (token.getStr().toUpperCase().equals("DEFAULT")) {
357	0	next();
358	0	if (token.getStr().equals("'")) {
359	0	next();
360		}
361	0	columnDefault = token.getStr();
362	0	next();
363	0	if (token.getStr().equals("'")) {
364	0	next();
365		}
366		}
367		// skip until ,
368	0	next();
369		}
370	0	next(); // skip ,
371	0	columnType = "VARCHAR";
372	0	} else if (token.getStr().toUpperCase().equals("(")) {
373	0	next();
374	0	columnSize = token.getStr();
375	0	next();
376	0	if (token.getStr().equals(",")) {
377	0	next();
378	0	columnPrecision = token.getStr();
379	0	next();
380		}
381
382	0	if (!token.getStr().equals(")")) {
383	0	err(") expected");
384		}
385	0	next();
386		}
387
388	0	Column col = new Column(columnName);
389	0	if (columnPrecision != null) {
390	0	columnSize = columnSize + columnPrecision;
391		}
392	0	col.setTypeFromString(columnType, columnSize);
393	0	tbl.addColumn(col);
394
395	0	if (inEnum) {
396	0	col.setNotNull(true);
397	0	if (columnDefault != null) {
398	0	col.setDefaultValue(columnDefault);
399		}
400		} else {
401	0	while (!token.getStr().equals(",") && !token.getStr().equals(")")) {
402	0	if (token.getStr().toUpperCase().equals("NOT")) {
403	0	next();
404	0	if (!token.getStr().toUpperCase().equals("NULL")) {
405	0	err("NULL expected after NOT");
406		}
407	0	col.setNotNull(true);
408	0	next();
409	0	} else if (token.getStr().toUpperCase().equals("PRIMARY")) {
410	0	next();
411	0	if (!token.getStr().toUpperCase().equals("KEY")) {
412	0	err("KEY expected after PRIMARY");
413		}
414	0	col.setPrimaryKey(true);
415	0	next();
416	0	} else if (token.getStr().toUpperCase().equals("UNIQUE")) {
417	0	col.setUnique(true);
418	0	next();
419	0	} else if (token.getStr().toUpperCase().equals("NULL")) {
420	0	col.setNotNull(false);
421	0	next();
422	0	} else if (token.getStr().toUpperCase().equals("AUTO_INCREMENT")) {
423	0	col.setAutoIncrement(true);
424	0	next();
425	0	} else if (token.getStr().toUpperCase().equals("DEFAULT")) {
426	0	next();
427	0	if (token.getStr().equals("'")) {
428	0	next();
429		}
430	0	col.setDefaultValue(token.getStr());
431	0	next();
432	0	if (token.getStr().equals("'")) {
433	0	next();
434		}
435		} else {
436	0	StringBuffer line = new StringBuffer();
437	0	for (Iterator tokenIt = tokens.iterator(); tokenIt.hasNext();) {
438	0	line.append(tokenIt.next());
439	0	if (tokenIt.hasNext()) {
440	0	line.append(" ");
441		}
442		}
443	0	throw new ParseException("Error parsing line " + line + " : Unknown token Nr. " + count + " : "
444		+ token);
445		}
446		}
447	0	next(); // eat the ,
448		}
449	0	}
450
451		/**
452		* Execute the parser.
453		*
454		* @throws IOException
455		* If an I/O error occurs
456		* @throws ParseException
457		* error parsing the input file
458		*/
459		public Database execute() throws IOException, ParseException {
460	0	count = 0;
461	0	appDataDB = new Database(databaseType);
462
463	0	FileReader fr = new FileReader(sqlFile);
464	0	BufferedReader br = new BufferedReader(fr);
465	0	SQLScanner scanner = new SQLScanner(br);
466
467	0	tokens = scanner.scan();
468
469	0	br.close();
470
471	0	while (hasTokens()) {
472	0	if (token == null) {
473	0	next();
474		}
475
476	0	if (token.getStr().toUpperCase().equals("CREATE")) {
477	0	create();
478		}
479	0	if (hasTokens()) {
480	0	next();
481		}
482		}
483	0	return appDataDB;
484		}
485		}