Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2007 Daniel Spiewak
   * 
   * Licensed 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.
  */
 package net.java.ao;
 
 
 import java.util.List;
 import java.util.Map;
 
 import static com.google.common.collect.Iterables.transform;
 import static com.google.common.collect.Lists.*;
 import static com.google.common.collect.Maps.*;

Author(s):
Daniel Spiewak
 
 public class Query implements Serializable
 {
     public enum QueryType
     {
         SELECT
     }
 
     private final static String PRIMARY_KEY_FIELD = "''''primary_key_field''''";
 	
 	private final QueryType type;
 	private String fields;
 	
 	private boolean distinct = false;
 	
 	private Class<? extends RawEntity<?>> tableType;
 	private String table;
 	
 	private String whereClause;
 	private Object[] whereParams;
 	
 	private String orderClause;
 	private String groupClause;
 	private int limit = -1;
 	private int offset = -1;
 	
 	private Map<Class<? extends RawEntity<?>>, Stringjoins;
     private Map<Class<? extends RawEntity<?>>, Stringaliases = newHashMap();
 	
 	public Query(QueryType typeString fields) {
 		this. = type;
 		this. = fields;
 		
 		 = new LinkedHashMap<Class<? extends RawEntity<?>>, String>();
 	}
 
     public Iterable<StringgetFields()
     {
         if (.contains())
         {
             return Collections.emptyList();
         }
         else
         {
             return ImmutableList.copyOf(transform(newArrayList(.split(",")), new Function<StringString>()
             {
                 @Override
                 public String apply(String field)
                 {
                     return field.trim();
                 }
             }));
         }
     }
 
     void setFields(String[] fields) {
 		if (fields.length == 0) {
 			return;
 		}
		StringBuilder builder = new StringBuilder();
		for (String field : fields) {
			builder.append(field).append(',');
		}
		if (fields.length > 1) {
			builder.setLength(builder.length() - 1);
		}
		this. = builder.toString();
	}
	<K> void resolvePrimaryKey(FieldInfo<K> fieldInfo) {
	}
	public Query distinct() {
		 = true;
		return this;
	}
	public Query from(Class<? extends RawEntity<?>> tableType) {
		 = null;
		this. = tableType;
		return this;
	}
	public Query from(String table) {
		 = null;
		this. = table;
		return this;
	}
	public Query where(String clauseObject... params) {
		 = clause;
		return this;
	}
	public Query order(String clause) {
		 = clause;
		return this;
	}
	public Query group(String clause) {
		 = clause;
		return this;
	}
	public Query limit(int limit) {
		this. = limit;
		return this;
	}
	public Query offset(int offset) {
		this. = offset;
		return this;
	}
    public Query alias(Class<? extends RawEntity<?>> tableString alias)
    {
        if (.containsValue(alias))
        {
            throw new ActiveObjectsException("There is already a table aliased '" + alias + "' for this query!");
        }
        .put(tablealias);
        return this;
    }
    public String getAlias(Class<? extends RawEntity<?>> table)
    {
        return .get(table);
    }
	public Query join(Class<? extends RawEntity<?>> joinString on) {
		.put(joinon);
		return this;
	}
	public Query join(Class<? extends RawEntity<?>> join) {
		.put(joinnull);
		return this;
	}
	public boolean isDistinct() {
		return ;
	}
	public void setDistinct(boolean distinct) {
		this. = distinct;
	}
	public Class<? extends RawEntity<?>> getTableType() {
		return ;
	}
	public void setTableType(Class<? extends RawEntity<?>> tableType) {
		this. = tableType;
	}
	public String getTable() {
		return ;
	}
	public void setTable(String table) {
		this. = table;
	}
	public String getWhereClause() {
		return ;
	}
	public void setWhereClause(String whereClause) {
		this. = whereClause;
	}
	public Object[] getWhereParams() {
		return ;
	}
	public void setWhereParams(Object[] whereParams) {
		this. = whereParams;
		if (whereParams != null) {
			for (int i = 0; i < whereParams.lengthi++) {
				if (whereParams[iinstanceof RawEntity<?>) {
					whereParams[i] = Common.getPrimaryKeyValue((RawEntity<?>) whereParams[i]);
				}
			}
		}
	}
	public String getOrderClause() {
		return ;
	}
	public void setOrderClause(String orderClause) {
		this. = orderClause;
	}
	public String getGroupClause() {
		return ;
	}
	public void setGroupClause(String groupClause) {
		this. = groupClause;
	}
	public int getLimit() {
		return ;
	}
	public void setLimit(int limit) {
		this. = limit;
	}
	public int getOffset() {
		return ;
	}
	public void setOffset(int offset) {
		this. = offset;
	}
	public Map<Class<? extends RawEntity<?>>, StringgetJoins() {
		return Collections.unmodifiableMap();
	}
	public void setJoins(Map<Class<? extends RawEntity<?>>, Stringjoins) {
		this. = joins;
	}
	public QueryType getType() {
		return ;
	}
	public String[] getCanonicalFields(EntityInfo<?, ?> entityInfo) {
        String[] back = .split(",");
               
        List<Stringresult = new ArrayList<String>();
		for(String fieldName : back) {
            if (fieldName.trim().equals("*")) {
                for (FieldInfo<?> fieldInfo : entityInfo.getFields()) {
					result.add(fieldInfo.getName());
				}
			}  else {
                result.add(fieldName.trim());
            }
        }
		return result.toArray(new String[result.size()]);
	}
	protected <K> String toSQL(EntityInfo<? extends RawEntity<K>, K> entityInfoDatabaseProvider providerTableNameConverter converterboolean count) {
		if (this. == null &&  == null) {
			this. = entityInfo.getEntityType();
		}
		return provider.renderQuery(thisconvertercount);
	}
	@SuppressWarnings("unchecked")
	protected void setParameters(EntityManager managerPreparedStatement stmtthrows SQLException {
		if ( != null) {
			final TypeManager typeManager = manager.getProvider().getTypeManager();
			for (int i = 0; i < .i++) {
				if ([i] == null) {
					manager.getProvider().putNull(stmti + 1);
else {
					Class javaType = [i].getClass();
					if ([iinstanceof RawEntity) {
						javaType = ((RawEntity[i]).getEntityType();
					}
					TypeInfo<ObjecttypeInfo = typeManager.getType(javaType);
					typeInfo.getLogicalType().putToDatabase(managerstmti + 1, [i], typeInfo.getJdbcWriteType());
				}
			}
		}
	}
	public static Query select() {
	}
	public static Query select(String fields) {
		return new Query(.fields);
	}
New to GrepCode? Check out our FAQ X