org.nutz.dao.util.Pojos Maven / Gradle / Ivy

Go to download
package org.nutz.dao.util;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;

import org.nutz.dao.Chain;
import org.nutz.dao.Condition;
import org.nutz.dao.DaoException;
import org.nutz.dao.FieldFilter;
import org.nutz.dao.FieldMatcher;
import org.nutz.dao.entity.Entity;
import org.nutz.dao.entity.EntityField;
import org.nutz.dao.entity.MappingField;
import org.nutz.dao.entity.PkType;
import org.nutz.dao.impl.jdbc.NutPojo;
import org.nutz.dao.impl.sql.pojo.ConditionPItem;
import org.nutz.dao.impl.sql.pojo.EntityTableNamePItem;
import org.nutz.dao.impl.sql.pojo.EntityViewNamePItem;
import org.nutz.dao.impl.sql.pojo.InsertFieldsPItem;
import org.nutz.dao.impl.sql.pojo.InsertValuesPItem;
import org.nutz.dao.impl.sql.pojo.PkConditionPItem;
import org.nutz.dao.impl.sql.pojo.QueryEntityFieldsPItem;
import org.nutz.dao.impl.sql.pojo.SingleColumnCondtionPItem;
import org.nutz.dao.impl.sql.pojo.SqlTypePItem;
import org.nutz.dao.impl.sql.pojo.StaticPItem;
import org.nutz.dao.impl.sql.pojo.UpdateFieldsByChainPItem;
import org.nutz.dao.impl.sql.pojo.UpdateFieldsPItem;
import org.nutz.dao.jdbc.JdbcExpert;
import org.nutz.dao.jdbc.ValueAdaptor;
import org.nutz.dao.pager.Pager;
import org.nutz.dao.sql.Criteria;
import org.nutz.dao.sql.PItem;
import org.nutz.dao.sql.Pojo;
import org.nutz.dao.sql.PojoCallback;
import org.nutz.dao.sql.SqlType;
import org.nutz.lang.Lang;
import org.nutz.lang.Strings;
import org.nutz.log.Log;
import org.nutz.log.Logs;

public abstract class Pojos {

	public static final Log log = Logs.get();
	
	// ==========================================================
	// 以下是创建 POJO 语句元素的帮助方法
	public static class Items {

		public static PItem sqlType() {
			return new SqlTypePItem();
		}

		public static PItem entityTableName() {
			return new EntityTableNamePItem();
		}

		public static PItem entityViewName() {
			return new EntityViewNamePItem();
		}

		public static PItem wrap(String str) {
			return new StaticPItem(str);
		}

		public static PItem wrapf(String fmt, Object... args) {
			return new StaticPItem(String.format(fmt, args));
		}

		public static PItem insertFields() {
			return new InsertFieldsPItem();
		}

		public static PItem insertValues() {
			return new InsertValuesPItem();
		}

		public static PItem updateFields(Object refer) {
			return new UpdateFieldsPItem(refer);
		}

		public static PItem updateFieldsBy(Chain chain) {
			return new UpdateFieldsByChainPItem(chain);
		}

		public static PItem queryEntityFields() {
			return new QueryEntityFieldsPItem();
		}

		public static PItem cndId(Entity en, Number id) {
		    MappingField mappingField = en.getIdField();
		    if (mappingField == null)
		        throw new DaoException("expect @Id but NOT found. " + en.getType().getName());
			return cndColumn(mappingField, id);
		}

		public static PItem cndName(Entity en, String name) {
		    MappingField mappingField = en.getNameField();
            if (mappingField == null)
                throw new DaoException("expect @Name but NOT found. " + en.getType().getName());
			return cndColumn(mappingField, name);
		}

		public static PItem cndColumn(MappingField mappingField, Object def) {
			SingleColumnCondtionPItem re = new SingleColumnCondtionPItem(mappingField, def);
			re.setCasesensitive(mappingField.isCasesensitive());
			return re;
		}

		public static PItem cndColumn(String colName, MappingField mappingField, Object def) {
			return new SingleColumnCondtionPItem(	colName,
													mappingField.getTypeClass(),
													mappingField.getAdaptor(),
													def);
		}

		public static PItem cndPk(Entity en, Object[] pks) {
			ValueAdaptor[] vas = new ValueAdaptor[en.getCompositePKFields().size()];
			int i = 0;
			for (MappingField mf : en.getCompositePKFields())
				vas[i++] = mf.getAdaptor();
			return new PkConditionPItem(vas, pks);
		}

		public static PItem cndAuto(Entity en, Object obj) {
			obj = Lang.first(obj);
			switch (en.getPkType()) {
			case ID:
				Number id = null != obj ? ((Number) en.getIdField().getValue(obj)) : null;
				return cndId(en, id);
			case NAME:
				String name = null != obj ? Strings.sNull(en.getNameField().getValue(obj), null) : null;
				return cndName(en, name);
			case COMPOSITE:
				Object[] pks = null;
				if (null != obj) {
					pks = new Object[en.getCompositePKFields().size()];
					int i = 0;
					for (EntityField ef : en.getCompositePKFields())
						pks[i++] = ef.getValue(obj);
				}
				return cndPk(en, pks);
			default:
				if (Map.class.isAssignableFrom(en.getType())) {
					return null; // Map形式的话,不一定需要主键嘛
				}
				throw Lang.makeThrow("Don't know how to make fetch key %s:'%s'", en.getType()
																					.getName(), obj);
			}
		}

		public static PItem[] cnd(Condition cnd) {
			List list = new LinkedList();
			if (null == cnd) {}
			// 高级条件
			else if (cnd instanceof Criteria) {
				list.add((Criteria) cnd);
			}
			// 普通条件
			else {
				list.add(new ConditionPItem(cnd));
			}
			return list.toArray(new PItem[list.size()]);
		}

		public static Pager pager(Condition cnd) {
			if (null == cnd) {
				return null;
			}
			// 高级条件
			else if (cnd instanceof Criteria) {
				return ((Criteria) cnd).getPager();
			}
			// 普通条件
			else {
				return null;
			}
		}

	}

	// 以上是创建 POJO 语句元素的帮助方法
	// ==========================================================

	public static Pojo createRun(PojoCallback callback) {
		return new NutPojo().setSqlType(SqlType.RUN).setAfter(callback);
	}

    public static List getFieldsForInsert(Entity en, FieldMatcher fm) {
        List re = new ArrayList(en.getMappingFields().size());
        for (MappingField mf : en.getMappingFields()) {
            if (null == fm || fm.match(mf.getName())) {
                if (!mf.isAutoIncreasement() && !mf.isReadonly() && mf.isInsert()) {
                    re.add(mf);
                } else if (fm != null && mf.isId() && !fm.isIgnoreId()) {
                    re.add(mf);
                }
            }
        }
        if (re.isEmpty() && log.isDebugEnabled())
            log.debug("none field for insert!");
        return re;
    }

	public static List getFieldsForUpdate(Entity en, FieldMatcher fm, Object refer) {
		List re = new ArrayList(en.getMappingFields().size());
		for (MappingField mf : en.getMappingFields()) {
			if (mf.isPk()) {
				if (en.getPkType() == PkType.ID && mf.isId())
					continue;
				if (en.getPkType() == PkType.NAME && mf.isName())
					continue;
				if (en.getPkType() == PkType.COMPOSITE && mf.isCompositePk())
					continue;
			}
			if (mf.isReadonly() || mf.isAutoIncreasement() || !mf.isUpdate())
				continue;
			else if (null != fm 
			      && null != refer 
			      && fm.isIgnoreNull() 
			      && null == mf.getValue(Lang.first(refer)))
				continue;
			if (null == fm || fm.match(mf.getName()))
				re.add(mf);
		}
		if (re.isEmpty() && log.isDebugEnabled())
			log.debug("none field for update!");
		return re;
	}

	private static final Pattern ptn = Pattern.compile(	"^(WHERE|ORDER BY)(.+)",
														Pattern.CASE_INSENSITIVE);

	public static String formatCondition(Entity en, Condition cnd) {
		if (null != cnd) {
			String str = Strings.trim(cnd.toSql(en));
			if (!ptn.matcher(str).find())
				return "WHERE " + str;
			return str;
		}
		return "";
	}

	public static Pojo pojo(JdbcExpert expert, Entity en, SqlType type) {
		Pojo pojo = expert.createPojo(type);
		pojo.getContext().setFieldMatcher(FieldFilter.get(en.getType()));
		return pojo;
	}

}