Samples.java

Violations

Source code

/*
  * hgcommons 9
 * Hammurapi Group Common Library
 * Copyright (C) 2003  Hammurapi Group
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * URL: http://www.hammurapi.biz/hammurapi-biz/ef/xmenu/hammurapi-group/products/products/hgcommons/index.html
 * e-Mail: support@hammurapi.biz
 */
package biz.hammurapi.sql;

import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

import javax.sql.DataSource;

import biz.hammurapi.sql.hsqldb.HsqldbStandaloneDataSource;

/**
 * @author Pavel Vlasov
 * @version $Revision: 1.6 $
 */
public class Samples {

	public static void main(String[] args) throws Exception {
		sample1();
	}

	private static final String CREATE_TABLE_SQL=
		"CREATE CACHED TABLE PERSON " +
		"(ID INTEGER IDENTITY NOT NULL PRIMARY KEY, " +
		"FIRST_NAME VARCHAR(30), LAST_NAME VARCHAR(30))";
	
	interface Person {
		String getFirstName();
		String getLastName();
		
		void setFirstName(String firstName);
		void setLastName(String lastName);
	}

	private static void sample1() throws Exception {
		DataSource dataSource=new HsqldbStandaloneDataSource(
				"People", 
				new Transaction() {

					public boolean execute(SQLProcessor processor) throws SQLException {
						processor.processUpdate(CREATE_TABLE_SQL, null);
						return true;
					}
					
				});
		
		SQLProcessor processor=new SQLProcessor(dataSource, null);
//		processor.setMeasurementConsumer(new SimpleMeasurementConsumer());		

		processor.processUpdate("INSERT INTO PERSON (FIRST_NAME, LAST_NAME) VALUES ('Pavel', 'Vlasov')", null);
		Iterator it= processor.project("SELECT * FROM PERSON", null, Person.class).iterator();
		while (it.hasNext()) {
			System.out.println(it.next());
		}
		
		sample2(processor);
		
		//System.out.println("SQL metrics: \n"+processor.getMeasurementConsumer());

	}

	private static void sample2(SQLProcessor processor) throws SQLException {
		processor.processSelect("SELECT * FROM PERSON", null, new RowProcessor() {
			public boolean process(ResultSet rs) throws SQLException {
				System.out.println(rs.getInt("ID")+" "+rs.getString("LAST_NAME"));
				return true;
			}			
		});
	}
	
	private static String sample3(SQLProcessor processor) throws SQLException {
		final String[] ret={null};
		processor.processSelect(
			"SELECT * FROM PERSON WHERE LAST_NAME=?", 
			new Parameterizer() {
				public int parameterize(PreparedStatement ps, int idx) throws SQLException {
					ps.setString(idx++, "VLASOV");
					return idx;
				}
			}, 
			new RowProcessor() {
				public boolean process(ResultSet rs) throws SQLException {
					ret[0]=rs.getString("LAST_NAME");
					return false;
				}			
		});
		return ret[0];
	}
	
	private static void updateOrInsert(
			final SQLProcessor processor, 
			final String firstName, 
			final String lastName) 
	throws SQLException {
		final Parameterizer parameterizer=new Parameterizer() {
			public int parameterize(PreparedStatement ps, int idx) throws SQLException {
				ps.setString(idx++, firstName);
				ps.setString(idx++, lastName);
				return idx;
			}
		};
		
		processor.processSelect(
			"SELECT * FROM PERSON WHERE LAST_NAME=?", 
			new Parameterizer() {
				public int parameterize(PreparedStatement ps, int idx) throws SQLException {
					ps.setString(idx++, lastName);
					return idx;
				}
			}, 
			new RowProcessorEx() {
				public boolean process(ResultSet rs) throws SQLException {
					processor.processUpdate(
							"UPDATE PERSON SET FIRST_NAME=? WHERE LAST_NAME=?",
							parameterizer);					
					return false;
				}

				public void onEmptyResultSet() throws SQLException {
					processor.processUpdate(
						"INSERT INTO PERSON (FIRST_NAME, LAST_NAME) VALUES (?, ?)",
						parameterizer);					
				}			
		});
	}
	
	class Person2 {
		private String firstName;
		private String lastName;

		public Person2(String firstName, String lastName) {
			this.firstName=firstName;
			this.lastName=lastName;
		}
		public String getFirstName() {
			return firstName;
		}
		public void setFirstName(String firstName) {
			this.firstName = firstName;
		}
		public String getLastName() {
			return lastName;
		}
		public void setLastName(String lastName) {
			this.lastName = lastName;
		}
	}
	
	private static void projection(SQLProcessor processor, final int personId) throws Exception {
		// Default - database backed

		Collection c=processor.project("SELECT * FROM PERSON");
		
		// Constructor - torn off

		Projector projector=new ConstructorProjector(Person2.class.getConstructor(new Class[] {String.class, String.class}), null);
		c=processor.project("SELECT FIRST_NAME, LAST_NAME FROM PERSON", null, projector, new ArrayList());
		
		// Property - paged, database backed

		projector=new PropertyProjector(Person2.class, null, null);
		c=processor.project("SELECT FIRST_NAME, LAST_NAME FROM PERSON", null, projector);
		
		// Interface - paged, torn off

		c=processor.project("SELECT * FROM PERSON", null, Person.class, new ArrayList(), 3, 15);
		
		// Single object projection

		projector=new PropertyProjector(Person2.class, null, null);
		Person2 person2=(Person2) processor.projectSingleObject("SELECT * FROM PERSON WHERE ID=2", null, projector);		
		
		// Single interface projection

		Person person=(Person) processor.projectSingleObject(
				"SELECT * FROM PERSON WHERE ID=?", 
				new Parameterizer() {
					public int parameterize(PreparedStatement ps, int idx) throws SQLException {
						ps.setInt(idx++, personId);
						return idx;
					}
				},
				Person.class);
	}	
	
	static class Person3 {
		private String firstName;
		private String lastName;

		public String getFirstName() {
			return firstName;
		}
		public void setFirstName(String firstName) {
			this.firstName = firstName;
		}
		public String getLastName() {
			return lastName;
		}
		public void setLastName(String lastName) {
			this.lastName = lastName;
		}
	}
	
	private static void injection(SQLProcessor processor, final int personId) throws Exception {
		Person3 person=new Person3();
		processor.inject("SELECT * FROM PERSON WHERE ID=2", null, null, person);		
		
		// Single interface projection

		processor.inject(
				"SELECT * FROM PERSON WHERE ID=?", 
				new Parameterizer() {
					public int parameterize(PreparedStatement ps, int idx) throws SQLException {
						ps.setInt(idx++, personId);
						return idx;
					}
				},
				null,
				person);
	}	
}