protected void AddAutoUpdateWhereBindVariables(ArrayList varList, ArrayList varTypeList, Object bean)
{
IBeanMetaData bmd = BeanMetaData;
for (int i = 0; i < bmd.PrimaryKeySize; ++i)
{
IPropertyType pt = bmd.GetPropertyTypeByColumnName(bmd.GetPrimaryKey(i));
PropertyInfo pi = pt.PropertyInfo;
varList.Add(pi.GetValue(bean, null));
varTypeList.Add(pi.PropertyType);
}
if (bmd.HasVersionNoPropertyType)
{
IPropertyType pt = bmd.VersionNoPropertyType;
PropertyInfo pi = pt.PropertyInfo;
varList.Add(pi.GetValue(bean, null));
varTypeList.Add(pi.PropertyType);
}
if (bmd.HasTimestampPropertyType)
{
IPropertyType pt = bmd.TimestampPropertyType;
PropertyInfo pi = pt.PropertyInfo;
varList.Add(pi.GetValue(bean, null));
varTypeList.Add(pi.PropertyType);
}
}
// ===============================================================================
// OutsideSql Override
// ===================
// -------------------------------------------------
// Traditional OutsideSql
// ----------------------
protected override void SetupSelectMethodByManual(MethodInfo mi, string sql)
{
string[] parameterNames = MethodUtil.GetParameterNames(mi);
Type[] parameterTypes = MethodUtil.GetParameterTypes(mi);
string[] filteredParameterNames = null;
Type[] filteredParameterTypes = null;
if (parameterTypes != null && parameterTypes.Length > 0 &&
typeof(CursorHandler).IsAssignableFrom(parameterTypes[parameterTypes.Length - 1]))
{
filteredParameterNames = new string[parameterTypes.Length - 1];
filteredParameterTypes = new Type[parameterTypes.Length - 1];
for (int i = 0; i < parameterTypes.Length - 1; i++)
{
filteredParameterNames[i] = parameterNames[i];
filteredParameterTypes[i] = parameterTypes[i];
}
}
else
{
filteredParameterNames = parameterNames;
filteredParameterTypes = parameterTypes;
}
IBeanMetaData myMetaData = GetOutsideSqlBeanMetaData(mi, _dbMetaData, _dbms);
IDataReaderHandler myDataReaderHandler = CreateDataReaderHandler(mi, myMetaData);
RegisterSqlCommand(mi.Name, mi, sql, filteredParameterNames, filteredParameterTypes, myDataReaderHandler);
}
// ===============================================================================
// Constructor
// ===========
public InternalInsertAutoDynamicCommand(IDataSource dataSource, ICommandFactory commandFactory,
IBeanMetaData beanMetaData, string[] propertyNames)
: base(dataSource, commandFactory)
{
_beanMetaData = beanMetaData;
_propertyNames = propertyNames;
}
protected virtual string SetupSql(IBeanMetaData bmd, IPropertyType[] propertyTypes)
{
StringBuilder buf = new StringBuilder(100);
buf.Append("INSERT INTO ");
buf.Append(bmd.TableName);
buf.Append(" (");
for (int i = 0; i < propertyTypes.Length; ++i)
{
IPropertyType pt = propertyTypes[i];
String columnName = pt.ColumnName;
if (i > 0)
{
buf.Append(", ");
}
buf.Append(columnName);
}
buf.Append(") VALUES (");
for (int i = 0; i < propertyTypes.Length; ++i)
{
if (i > 0)
{
buf.Append(", ");
}
buf.Append("?");
}
buf.Append(")");
return(buf.ToString());
}
// ===============================================================================
// Constructor
// ===========
public InternalAbstractAutoStaticCommand(IDataSource dataSource,
ICommandFactory commandFactory, IBeanMetaData beanMetaData, string[] propertyNames)
: base(dataSource, commandFactory, beanMetaData)
{
SetupPropertyTypes(propertyNames);
SetupSql();
}
protected void SetupUpdateWhere(StringBuilder sb)
{
IBeanMetaData bmd = BeanMetaData;
sb.Append(" WHERE ");
for (int i = 0; i < bmd.PrimaryKeySize; ++i)
{
sb.Append(bmd.GetPrimaryKey(i));
sb.Append(" = ? AND ");
}
sb.Length = sb.Length - 5;
if (bmd.HasVersionNoPropertyType)
{
IPropertyType pt = bmd.VersionNoPropertyType;
sb.Append(" AND ");
sb.Append(pt.ColumnName);
sb.Append(" = ?");
}
if (bmd.HasTimestampPropertyType)
{
IPropertyType pt = bmd.TimestampPropertyType;
sb.Append(" AND ");
sb.Append(pt.ColumnName);
sb.Append(" = ?");
}
}
protected virtual string CreateNoUpdateLogMessage(object bean, IBeanMetaData bmd)
{
StringBuilder builder = new StringBuilder();
builder.Append("skip UPDATE: table=");
builder.Append(bmd.TableName);
int size = bmd.PrimaryKeySize;
for (int i = 0; i < size; i++)
{
if (i == 0)
{
builder.Append(", key{");
}
else
{
builder.Append(", ");
}
string keyName = bmd.GetPrimaryKey(i);
builder.Append(keyName);
builder.Append("=");
builder.Append(bmd.GetPropertyTypeByColumnName(keyName)
.PropertyInfo.GetValue(bean, null));
if (i == size - 1)
{
builder.Append("}");
}
}
return(builder.ToString());
}
protected override IPropertyType[] CreateTargetPropertyTypes(IBeanMetaData bmd, object bean, string[] propertyNames)
{
IDictionary modifiedPropertyNames = bmd.GetModifiedPropertyNames(bean);
IList types = new ArrayList();
string timestampPropertyName = bmd.TimestampPropertyName;
string versionNoPropertyName = bmd.VersionNoPropertyName;
for (int i = 0; i < propertyNames.Length; ++i)
{
IPropertyType pt = bmd.GetPropertyType(propertyNames[i]);
if (pt.IsPrimaryKey == false)
{
string propertyName = pt.PropertyName;
if (propertyName.Equals(timestampPropertyName, StringComparison.CurrentCultureIgnoreCase) ||
propertyName.Equals(versionNoPropertyName, StringComparison.CurrentCultureIgnoreCase) ||
modifiedPropertyNames.Contains(propertyName))
{
types.Add(pt);
}
}
}
IPropertyType[] propertyTypes = new IPropertyType[types.Count];
types.CopyTo(propertyTypes, 0);
return(propertyTypes);
}
protected virtual bool CanExecute(object bean, IBeanMetaData bmd, IPropertyType[] propertyTypes, string[] propertyNames)
{
if (propertyTypes.Length == 0)
{
throw new SRuntimeException("EDAO0014");
}
return(true);
}
// ===============================================================================
// Constructor
// ===========
public InternalAbstractAutoHandler(IDataSource dataSource, ICommandFactory commandFactory,
IBeanMetaData beanMetaData, IPropertyType[] propertyTypes) : base(dataSource, null, commandFactory)
{
// The property of Sql is treated as lazy setting at this class!
DataSource = dataSource;// This is for this new method!
_beanMetaData = beanMetaData;
_propertyTypes = propertyTypes;
}
protected virtual InternalAbstractAutoHandler CreateInternalAutoHandler(IDataSource dataSource, ICommandFactory commandFactory,
IBeanMetaData beanMetaData, IPropertyType[] propertyTypes)
{
InternalUpdateAutoHandler handler = new InternalUpdateAutoHandler(dataSource, commandFactory, beanMetaData, propertyTypes);
handler.VersionNoAutoIncrementOnMemory = _versionNoAutoIncrementOnMemory;
handler.IsCheckSingleRowUpdate = IsCheckSingleRowUpdate; // [DBFlute-0.8.0]
return(handler);
}
protected void CheckPrimaryKey()
{
IBeanMetaData bmd = BeanMetaData;
if (bmd.PrimaryKeySize == 0)
{
throw new PrimaryKeyNotFoundRuntimeException(bmd.BeanType);
}
}
protected virtual String CreateUpdateSql(IBeanMetaData bmd, IPropertyType[] propertyTypes, Object bean)
{
if (bmd.PrimaryKeySize == 0)
{
String msg = "The table '" + bmd.TableName + "' does not have primary keys!";
throw new SystemException(msg);
}
StringBuilder sb = new StringBuilder(100);
sb.Append("UPDATE ").Append(bmd.TableName).Append(" SET ");
String versionNoPropertyName = bmd.VersionNoPropertyName;
for (int i = 0; i < propertyTypes.Length; ++i)
{
IPropertyType pt = propertyTypes[i];
String columnName = pt.ColumnName;
if (i > 0)
{
sb.Append(", ");
}
if (String.Compare(pt.PropertyName, versionNoPropertyName, true) == 0)
{
if (!IsVersionNoAutoIncrementOnMemory())
{
SetupVersionNoAutoIncrementOnQuery(sb, columnName);
continue;// because of always 'VERSION_NO = VERSION_NO + 1'
}
Object value = pt.PropertyInfo.GetValue(bean, null);
if (value == null)
{
SetupVersionNoAutoIncrementOnQuery(sb, columnName);
continue;
}
}
sb.Append(columnName).Append(" = ?");
}
sb.Append(" WHERE ");
const string ADD_AND = " AND ";
for (int i = 0; i < bmd.PrimaryKeySize; ++i)
{
sb.Append(bmd.GetPrimaryKey(i)).Append(" = ?").Append(ADD_AND);
}
sb.Length = sb.Length - ADD_AND.Length;
if (bmd.HasVersionNoPropertyType)
{
IPropertyType pt = bmd.VersionNoPropertyType;
sb.Append(ADD_AND).Append(pt.ColumnName).Append(" = ?");
}
if (bmd.HasTimestampPropertyType)
{
IPropertyType pt = bmd.TimestampPropertyType;
sb.Append(ADD_AND).Append(pt.ColumnName).Append(" = ?");
}
return(sb.ToString());
}
public virtual IDataReaderHandler GetResultSetHandler(Type beanType, IBeanMetaData bmd, MethodInfo mi)
{
Type retType = mi.ReturnType;
if (typeof(DataSet).IsAssignableFrom(retType))
{
return(CreateBeanDataSetMetaDataDataReaderHandler(bmd, retType));
}
else if (typeof(DataTable).IsAssignableFrom(retType))
{
return(CreateBeanDataTableMetaDataDataReaderHandler(bmd, retType));
}
else if (retType.IsArray)
{
Type elementType = retType.GetElementType();
if (AssignTypeUtil.IsSimpleType(elementType))
{
return(CreateObjectArrayDataReaderHandler(elementType));
}
else
{
return(CreateBeanArrayMetaDataDataReaderHandler(bmd));
}
}
else if (AssignTypeUtil.IsList(retType))
{
if (AssignTypeUtil.IsSimpleType(beanType))
{
return(CreateObjectListDataReaderHandler());
}
else
{
return(CreateBeanListMetaDataDataReaderHandler(bmd));
}
}
else if (IsBeanTypeAssignable(beanType, retType))
{
return(CreateBeanMetaDataDataReaderHandler(bmd));
}
else if (AssignTypeUtil.IsGenericList(retType))
{
Type elementType = retType.GetGenericArguments()[0];
if (AssignTypeUtil.IsSimpleType(elementType))
{
return(CreateObjectGenericListDataReaderHandler(elementType));
}
else
{
return(CreateBeanGenericListMetaDataDataReaderHandler(bmd));
}
}
else
{
return(CreateObjectDataReaderHandler());
}
}
protected virtual void PostCreateRow(Object row, IBeanMetaData bmd)
{
if (row is Entity) // DBFlute Target
{
((Entity)row).ClearModifiedPropertyNames();
}
else // Basically Unreachable
{
bmd.ClearModifiedPropertyNames(row);
}
}
public IBeanMetaData FindCachedMeta(Type beanClass)
{
if (IsDBFluteEntity(beanClass))
{
IBeanMetaData cachedMeta = GetMetaFromCache(beanClass);
if (cachedMeta != null)
{
return(cachedMeta);
}
}
return(null);
}
protected RelationKey CreateRelationKey(IDataReader reader, IRelationPropertyType rpt
, System.Collections.IList columnNames, System.Collections.Hashtable relKeyValues
, Map <String, int?> selectIndexMap)
{
System.Collections.ArrayList keyList = new System.Collections.ArrayList();
IBeanMetaData bmd = rpt.BeanMetaData;
for (int i = 0; i < rpt.KeySize; ++i)
{
IValueType valueType = null;
IPropertyType pt = rpt.BeanMetaData.GetPropertyTypeByColumnName(rpt.GetYourKey(i));
String relationNoSuffix = BuildRelationNoSuffix(rpt);
String columnName = RemoveQuoteIfExists(pt.ColumnName) + relationNoSuffix;
if (columnNames.Contains(columnName))
{
valueType = pt.ValueType;
}
else
{
// basically unreachable
// because the referred column (basically PK or FK) must exist
// if the relation's select clause is specified
return(null);
}
Object value;
if (selectIndexMap != null)
{
value = GetValue(reader, columnName, valueType, selectIndexMap);
}
else
{
value = valueType.GetValue(reader, columnName);
}
if (value == null)
{
// reachable when the referred column data is null
// (treated as no relation data)
return(null);
}
relKeyValues[columnName] = value;
keyList.Add(value);
}
if (keyList.Count > 0)
{
object[] keys = keyList.ToArray();
return(new RelationKey(keys));
}
else
{
return(null);
}
}
protected override bool CanExecute(object bean, IBeanMetaData bmd, IPropertyType[] propertyTypes, String[] propertyNames)
{
if (propertyTypes.Length > 0)
{
return(true);
}
if (_log.IsDebugEnabled)
{
string s = CreateNoUpdateLogMessage(bean, bmd);
_log.Debug(s);
}
return(false);
}
protected override void SetupRelationKeyValue(RelationRowCreationResource res)
{
IRelationPropertyType rpt = res.RelationPropertyType;
IBeanMetaData bmd = rpt.BeanMetaData;
DBMeta dbmeta = FindDBMeta(bmd.BeanType, bmd.TableName);
for (int i = 0; i < rpt.KeySize; ++i)
{
String columnName = rpt.GetMyKey(i) + res.BaseSuffix;
if (!res.ContainsColumnName(columnName))
{
continue;
}
if (!res.HasRowInstance())
{
Object row;
if (dbmeta != null)
{
row = dbmeta.NewEntity();
}
else
{
row = NewRelationRow(rpt);
}
res.Row = row;
}
if (!res.ContainsRelKeyValueIfExists(columnName))
{
continue;
}
Object value = res.ExtractRelKeyValue(columnName);
if (value == null)
{
// basically no way
// because this is not called if the referred value
// is null (then it must be no relation key)
// @see InternalBeanListMetaDataResultSetHandler
continue;
}
String yourKey = rpt.GetYourKey(i);
IPropertyType pt = bmd.GetPropertyTypeByColumnName(yourKey);
PropertyInfo pi = pt.PropertyInfo;
pi.SetValue(res.Row, value, null);
continue;
}
}
public override void Initialize(IDatabaseMetaData dbMetaData, IDbms dbms)
{
if (_metaMap != null)
{
BeanMetaDataCacheHandler handler = new BeanMetaDataCacheHandler(_metaMap);
Type myBeanClass = BeanType;
if (handler.IsDBFluteEntity(myBeanClass))
{
IBeanMetaData cachedMeta = handler.GetMetaFromCache(myBeanClass);
if (cachedMeta == null)
{
handler.AddMetaFromCache(myBeanClass, this);
}
}
}
base.Initialize(dbMetaData, dbms);
}
protected virtual IPropertyType[] CreateTargetPropertyTypes(IBeanMetaData bmd, object bean, string[] propertyNames)
{
IList types = new ArrayList();
String timestampPropertyName = bmd.TimestampPropertyName;
String versionNoPropertyName = bmd.VersionNoPropertyName;
for (int i = 0; i < propertyNames.Length; ++i)
{
IPropertyType pt = bmd.GetPropertyType(propertyNames[i]);
if (IsTargetProperty(pt, timestampPropertyName, versionNoPropertyName, bean))
{
types.Add(pt);
}
}
IPropertyType[] propertyTypes = new IPropertyType[types.Count];
types.CopyTo(propertyTypes, 0);
return(propertyTypes);
}
public IBeanMetaData FindOrCreateCachedMetaIfNeeds(Type beanClass, IAnnotationReaderFactory factory, IDatabaseMetaData dbMetaData, IDbms dbms)
{
if (IsDBFluteEntity(beanClass))
{
IBeanMetaData cachedMeta = GetMetaFromCache(beanClass);
if (cachedMeta != null)
{
return(cachedMeta);
}
else
{
BeanMetaDataCacheExtension bmdExt = new BeanMetaDataCacheExtension(beanClass, factory, false);
bmdExt.MetaMap = _metaMap;
bmdExt.Initialize(dbMetaData, dbms);
return(bmdExt);
}
}
return(null);
}
protected override void SetupPropertyCache(RelationRowCreationResource res)
{
// - - - - - - - - - - -
// Recursive Call Point!
// - - - - - - - - - - -
res.InitializePropertyCacheElement();
// Do only selected foreign property for performance if condition-bean exists.
if (HasConditionBean(res) && !HasSelectedForeignInfo(res))
{
return;
}
// Set up property cache about current beanMetaData.
IBeanMetaData nextBmd = res.GetRelationBeanMetaData();
for (int i = 0; i < nextBmd.PropertyTypeSize; ++i)
{
IPropertyType pt = nextBmd.GetPropertyType(i);
res.CurrentPropertyType = pt;
if (!IsTargetProperty(res))
{
continue;
}
SetupPropertyCacheElement(res);
}
// Set up next relation.
if (res.HasNextRelationProperty() && (HasConditionBean(res) || res.HasNextRelationLevel()))
{
res.BackupRelationPropertyType();
res.IncrementCurrentRelationNestLevel();
try {
SetupNextPropertyCache(res, nextBmd);
} finally {
res.RestoreRelationPropertyType();
res.DecrementCurrentRelationNestLevel();
}
}
}
public override object Execute(object[] args)
{
Object bean = args[0];
IBeanMetaData bmd = BeanMetaData;
String[] propertyNames = PropertyNames;
IPropertyType[] propertyTypes = CreateTargetPropertyTypes(bmd, bean, propertyNames);
if (CanExecute(bean, bmd, propertyTypes, propertyNames) == false)
{
return(NO_UPDATE);
}
InternalAbstractAutoHandler handler = CreateInternalAutoHandler(DataSource, CommandFactory, bmd, propertyTypes);
handler.Sql = CreateUpdateSql(bmd, propertyTypes, bean);
int i = handler.Execute(args);
// [Comment Out]: This statement moved to the handler at DBFlute-0.8.0.
// if (IsCheckSingleRowUpdate && i < 1) {
// throw new NotSingleRowUpdatedRuntimeException(args[0], i);
// }
return(i);
}
protected override IBeanMetaData CreateRelationBeanMetaData(PropertyInfo propertyInfo, IDatabaseMetaData dbMetaData, IDbms dbms)
{
if (_metaMap != null)
{
BeanMetaDataCacheHandler handler = new BeanMetaDataCacheHandler(_metaMap);
IBeanMetaData cachedBmd = handler.FindOrCreateCachedMetaIfNeeds(propertyInfo.PropertyType, AnnotationReaderFactory, dbMetaData, dbms);
if (cachedBmd != null)
{
return(cachedBmd);
}
}
bool isRelation = false;
if (this.NestNo > 0)
{
isRelation = true;
}
BeanMetaDataCacheExtension bmdExt = new BeanMetaDataCacheExtension(propertyInfo.PropertyType, this.AnnotationReaderFactory, isRelation);
bmdExt.NestNo = this.NestNo + 1;
bmdExt.Initialize(dbMetaData, dbms);
return(bmdExt);
}
// ===============================================================================
// Execute
// =======
public override Object Execute(object[] args)
{
object bean = args[0];
IBeanMetaData bmd = BeanMetaData;
string[] propertyNames = PropertyNames;
IPropertyType[] propertyTypes = CreateTargetPropertyTypes(bmd, bean, propertyNames);
if (CanExecute(bean, bmd, propertyTypes, propertyNames) == false)
{
return(NO_UPDATE);
}
InternalAbstractAutoHandler handler = CreateAutoHandler(DataSource, CommandFactory, bmd, propertyTypes);
handler.Sql = SetupSql(bmd, propertyTypes);
handler.LoggingMessageSqlArgs = args; // Actually set up this property in the handler again.
int i = handler.Execute(args);
if (i < 1)
{
throw new NotSingleRowUpdatedRuntimeException(args[0], i);
}
return(i);
}
protected void SetupInsertSql()
{
IBeanMetaData bmd = BeanMetaData;
StringBuilder sb = new StringBuilder(100);
sb.Append("INSERT INTO ");
sb.Append(bmd.TableName);
sb.Append(" (");
for (int i = 0; i < propertyTypes.Length; ++i)
{
IPropertyType pt = propertyTypes[i];
sb.Append(pt.ColumnName);
sb.Append(", ");
}
sb.Length = sb.Length - 2;
sb.Append(") VALUES (");
for (int i = 0; i < propertyTypes.Length; ++i)
{
sb.Append("?, ");
}
sb.Length = sb.Length - 2;
sb.Append(")");
Sql = sb.ToString();
}
// ===============================================================================
// Constructor
// ===========
public InternalBeanArrayMetaDataResultSetHandler(IBeanMetaData beanMetaData, IRowCreator rowCreator, IRelationRowCreator relationRowCreator)
: base(beanMetaData, rowCreator, relationRowCreator)
{
}
// ===============================================================================
// Constructor
// ===========
public InternalUpdateAutoHandler(IDataSource dataSource, ICommandFactory commandFactory, IBeanMetaData beanMetaData, IPropertyType[] propertyTypes)
: base(dataSource, commandFactory, beanMetaData, propertyTypes)
{
}
protected virtual InternalAbstractAutoHandler CreateAutoHandler(IDataSource dataSource, ICommandFactory commandFactory,
IBeanMetaData beanMetaData, IPropertyType[] propertyTypes)
{
return(new InternalInsertAutoHandler(dataSource, commandFactory, beanMetaData, propertyTypes));
}
