// ===============================================================================
// Initialize
// ==========
public void InitializeConditionBeanMetaData()
{
Map <String, DBMeta> dbmetaMap = DBMetaInstanceHandler.GetUnmodifiableDBMetaMap();
Collection <DBMeta> dbmetas = dbmetaMap.values();
DateTime? before = null;
if (_log.IsInfoEnabled)
{
before = DateTime.Now;
_log.Info("/= = = = = = = = = = = = = = = = = InitializeConditionBeanMetaData()");
}
foreach (DBMeta dbmeta in dbmetas)
{
DaoReadable dao = DaoSelector.ByName(dbmeta.TableDbName);
MethodInfo method = dao.GetType().GetMethod("InitializeDaoMetaData");
if (method == null)
{
continue;
}
method.Invoke(dao, new Object[] { "SelectList" });
}
if (_log.IsInfoEnabled)
{
DateTime after = DateTime.Now;
_log.Info("Initialized Count: " + dbmetas.size());
_log.Info("= = = = = = = = = =/ [" + TraceViewUtil.ConvertToPerformanceView(before.Value, after) + "]");
}
}
protected void assertAliasName(String aliasName)
{
if (aliasName == null || aliasName.Trim().Length == 0)
{
throwDerivedReferrerInvalidAliasNameException();
}
DBMeta dbmeta = DBMetaInstanceHandler.FindDBMeta(_baseCB.TableDbName);
PropertyInfo[] properties = dbmeta.EntityType.GetProperties();
String targetPropertyName = aliasName.Replace("_", "").ToLower();
bool existsSetterMethod = false;
foreach (PropertyInfo property in properties)
{
if (!property.CanWrite)
{
continue;
}
if (targetPropertyName.Equals(property.Name.ToLower()))
{
existsSetterMethod = true;
break;
}
}
if (!existsSetterMethod)
{
throwDerivedReferrerEntityPropertyNotFoundException(aliasName, dbmeta.EntityType);
}
}
public virtual DaoReadable ByName(String tableFlexibleName)
{
AssertStringNotNullAndNotTrimmedEmpty("tableFlexibleName", tableFlexibleName);
DBMeta dbmeta = DBMetaInstanceHandler.FindDBMeta(tableFlexibleName);
return(InternalSelect <DaoReadable>(GetDaoType(dbmeta)));
}
public static DBMeta FindDBMeta(Type rowType, String tableName)
{
DBMeta dbmeta = FindCachedDBMeta(rowType);
if (dbmeta != null)
{
return(dbmeta);
}
try {
dbmeta = DBMetaInstanceHandler.FindDBMeta(tableName);
} catch (DBMetaNotFoundException) {
return(null);
}
CacheDBMeta(rowType, dbmeta);
return(dbmeta);
}
// ===================================================================================
// Lock Override
// =============
public override SqlClause lockForUpdate()
{
DBMeta dbmeta = DBMetaInstanceHandler.FindDBMeta(_tableName);
if (dbmeta.HasPrimaryKey)
{
String primaryKeyColumnName = dbmeta.PrimaryUniqueInfo.FirstColumn.ColumnDbName;
_lockSqlSuffix = " for update of " + _tableName + "." + primaryKeyColumnName;
}
else
{
String randomColumnName = dbmeta.ColumnInfoList.get(0).ColumnDbName;
_lockSqlSuffix = " for update of " + _tableName + "." + randomColumnName;
}
_lockSqlSuffix = " for update";
return(this);
}
protected String BuildBehaviorSqlPackageName()
{
DBMeta dbmeta = DBMetaInstanceHandler.FindDBMeta(_tableDbName);
String behaviorTypeName = dbmeta.BehaviorTypeName;
String outsideSqlPackage = DBFluteConfig.GetInstance().OutsideSqlPackage;
if (outsideSqlPackage != null && outsideSqlPackage.Trim().Length > 0)
{
String behaviorClassName = behaviorTypeName.Substring(behaviorTypeName.LastIndexOf(".") + ".".Length);
String tmp = behaviorTypeName.Substring(0, behaviorTypeName.LastIndexOf("."));
String exbhvName = tmp.Contains(".") ? tmp.Substring(tmp.LastIndexOf(".") + ".".Length) : tmp;
return(FilterBehaviorSqlPackageName(outsideSqlPackage + "." + exbhvName + "." + behaviorClassName));
}
else
{
return(FilterBehaviorSqlPackageName(behaviorTypeName));
}
}
/**
* @param cb Condition-bean. (NotNull)
* @param entity Entity. (NotNull)
* @return The two-way SQL of query update. (NullAllowed: If the set of modified properties is empty, return null.)
*/
protected String buildQueryUpdateTwoWaySql(ConditionBean cb, Entity entity)
{
Map <String, String> columnParameterMap = new LinkedHashMap <String, String>();
DBMeta dbmeta = DBMetaInstanceHandler.FindDBMeta(entity.TableDbName);
System.Collections.Generic.IDictionary <String, Object> modifiedPropertyNames = entity.ModifiedPropertyNames;
if (modifiedPropertyNames.Count == 0)
{
return(null);
}
String currentPropertyName = null;
foreach (String propertyName in modifiedPropertyNames.Keys)
{
currentPropertyName = propertyName;
ColumnInfo columnInfo = dbmeta.FindColumnInfo(propertyName);
String columnName = columnInfo.ColumnDbName;
PropertyInfo getter = columnInfo.FindProperty();
Object value = getter.GetValue(entity, null);
if (value != null)
{
columnParameterMap.put(columnName, "/*entity." + propertyName + "*/null");
}
else
{
columnParameterMap.put(columnName, "null");
}
}
if (dbmeta.HasVersionNo)
{
ColumnInfo columnInfo = dbmeta.VersionNoColumnInfo;
String columnName = columnInfo.ColumnDbName;
columnParameterMap.put(columnName, columnName + " + 1");
}
if (dbmeta.HasUpdateDate)
{
ColumnInfo columnInfo = dbmeta.UpdateDateColumnInfo;
PropertyInfo setter = columnInfo.FindProperty();
setter.SetValue(entity, DateTime.Now, null);
String columnName = columnInfo.ColumnDbName;
columnParameterMap.put(columnName, "/*entity." + columnInfo.PropertyName + "*/null");
}
return(cb.SqlClause.getClauseQueryUpdate(columnParameterMap));
}
// ===============================================================================
// Constructor
// ===========
public AbstractConditionBean()
{
DBMeta dbmeta = DBMetaInstanceHandler.FindDBMeta(TableDbName);
_sqlClause = new SqlClausePostgreSql(dbmeta.TableSqlName);
}
protected String buildInvocationExpressionWithoutKakko(IMethodInvocation invocation, String invokeClassName, String invokeMethodName)
{
if (invokeClassName.Contains("OutsideSql") && invokeClassName.Contains("Executor")) // OutsideSql Executor Handling and CSharp Only Contains
{
try {
String originalName = invokeClassName;
if (IsSpecifiedOutsideSql())
{
OutsideSqlContext outsideSqlContext = GetOutsideSqlContext();
String tableDbName = outsideSqlContext.TableDbName;
DBMeta dbmeta = DBMetaInstanceHandler.FindDBMeta(tableDbName);
String behaviorTypeName = dbmeta.BehaviorTypeName;
String behaviorClassName = behaviorTypeName.Substring(behaviorTypeName.LastIndexOf(".") + ".".Length);
invokeClassName = behaviorClassName + ".OutsideSql()";
if (originalName.Contains("OutsideSqlEntityExecutor")) // CSharp Only Contains
{
invokeClassName = invokeClassName + ".EntityHandling()";
}
else if (originalName.Contains("OutsideSqlPagingExecutor")) // CSharp Only Contains
{
if (outsideSqlContext.IsAutoPagingLogging)
{
invokeClassName = invokeClassName + ".AutoPaging()";
}
else
{
invokeClassName = invokeClassName + ".ManualPaging()";
}
}
else if (originalName.Contains("OutsideSqlCursorExecutor")) // CSharp Only Contains
{
invokeClassName = invokeClassName + ".CursorHandling()";
}
}
else
{
invokeClassName = "OutsideSql";
}
} catch (Exception ignored) {
Log("Ignored exception occurred: msg=" + ignored.Message);
}
}
String invocationExpressionWithoutKakko = invokeClassName + "." + invokeMethodName;
if ("SelectPage".Equals(invokeMethodName)) // Special Handling!
{
bool resultTypeInteger = false;
if (IsSpecifiedOutsideSql())
{
OutsideSqlContext outsideSqlContext = GetOutsideSqlContext();
Type resultType = outsideSqlContext.ResultType;
if (resultType != null)
{
if (typeof(int).IsAssignableFrom(resultType))
{
resultTypeInteger = true;
}
}
}
if (resultTypeInteger || "SelectCount".Equals(invocation.Method.Name))
{
invocationExpressionWithoutKakko = invocationExpressionWithoutKakko + "():count";
}
else
{
invocationExpressionWithoutKakko = invocationExpressionWithoutKakko + "():paging";
}
}
return(invocationExpressionWithoutKakko);
}
