func getPropertyValue(value interface{}, ctype string, currentName string) (string, interface{}) {
log.InternalDebug(fmt.Sprintf("value getPropertyValue %v %T %s\n", value, value, currentName))
xtype := GetType(value)
log.InternalDebug("xtype:" + xtype)
v := reflect.ValueOf(value).Elem()
log.InternalDebug(fmt.Sprintf("new v %v %T\n", v, v))
newv := v.FieldByName(InitCap(currentName))
log.InternalDebug(fmt.Sprintf("newv %v \n", newv))
if newv.IsValid() == false {
fmt.Printf("value %v %T\n", value, value)
fmt.Println("method" + InitCap(currentName))
test2 := reflect.ValueOf(value).MethodByName(InitCap(currentName))
if test2.IsValid() == false {
test2 = reflect.ValueOf(value).MethodByName("Get" + InitCap(currentName))
if test2.IsValid() == false {
return "", nil
}
}
nValuex := test2.Call([]reflect.Value{})
nValue := nValuex[0].Interface()
nType := GetType(nValue)
return nType, nValue
}
newValue := newv.Interface()
newType := GetType(newValue)
return newType, newValue
}
func (t *TnAbstractTwoWaySqlCommand) apply(rootNode *Node, args []interface{}, argNames []string, argTypes []string) *CommandContext {
log.InternalDebug("TnAbstractTwoWaySqlCommand apply")
log.InternalDebug(fmt.Sprintf("argNames %v argtypes %v \n", argNames, argTypes))
//fmt.Printf("rootNode %v \n", rootNode)
ctx := t.createCommandContext(args, argNames, argTypes)
(*rootNode).accept(ctx, rootNode)
//fmt.Println("sql apply %s"+(*ctx).getSql())
return ctx
}
func (r *SqlPartsNode) accept(ctx *CommandContext, node *Node) {
log.InternalDebug("SqlPartsNode accept")
(*ctx).addSql(r.sqlParts)
log.InternalDebug("SQL PART*" + r.sqlParts)
//以下未実装
// if (isMarkAlreadySkipped(ctx)) {
// // It does not skipped actually but it has not already needed to skip.
// ctx.setAlreadySkippedConnector(true);
// }
return
}
func (b *BindClauseResult) ToBindClause() string {
var clause string
//Temporary for T/S
// if b.Arranger != nil {
// clause = (*b.Arranger).Arrange(b.ColumnExp, b.Operand, b.BindExp, b.RearOption)
// } else {
clause = b.ColumnExp.ToString() + " " + b.Operand + " " +
b.BindExp + b.RearOption
// }
log.InternalDebug("operand :" + b.Operand)
log.InternalDebug("clause:" + clause)
log.InternalDebug("bindExp :" + b.BindExp)
log.InternalDebug("clause :" + clause)
return clause
}
func (t *TnBasicSelectHandler) execute(bindVariables *List, bindVariableTypes *StringList, tx *sql.Tx, behavior *Behavior) interface{} {
dbc := (*(*behavior).GetBaseBehavior().GetBehaviorCommandInvoker().InvokerAssistant).GetDBCurrent()
ps := (*t.statementFactory).PrepareStatement(t.sql, tx, dbc)
defer ps.Close()
bindVar := (*t.statementFactory).ModifyBindVariables(bindVariables, bindVariableTypes)
//ps := t.prepareStatement(tx, dbc)
// ns:=new(sql.NullString)
// ns.Valid=true
// ns.String="2"
// var itest interface{}=ns
t.logSql(bindVariables, bindVariableTypes)
var rows *sql.Rows
var err error
if bindVariables == nil {
rows, err = tx.Stmt(ps).Query()
if err != nil {
panic(err.Error())
}
} else {
rows, err = tx.Stmt(ps).Query(bindVar.data...)
if err != nil {
panic(err.Error())
}
}
log.InternalDebug(fmt.Sprintln("ResultType:", t.ResultType))
rh := new(ResultSetHandler)
//l := BhvUtil_I.GetListResultBean(rows, t.ResultType,t.SqlClause)
l := rh.GetListResultBean(rows, t.ResultType, t.SqlClause)
log.InternalDebug(fmt.Sprintln("result no:", l.List.Size()))
log.InternalDebug(fmt.Sprintf("data %v\n", l.List.Get(0)))
// logSql(args, argTypes);
// PreparedStatement ps = null;
// try {
// ps = prepareStatement(conn);
// bindArgs(conn, ps, args, argTypes);
// return queryResult(ps);
// } catch (SQLException e) {
// final SQLExceptionResource resource = createSQLExceptionResource();
// resource.setNotice("Failed to execute the SQL for select.");
// handleSQLException(e, resource);
// return null; // unreachable
// } finally {
// close(ps);
// }
return l
}
func (r *IfNode) doAcceptByEvaluator(ctx *CommandContext, loopInfo *LoopInfo) {
cmap := (*ctx).GetArgs()
cmap = cmap
//fmt.Printf("ctx %v \n", len(cmap))
evaluator := new(IfCommentEvaluator)
f := new(ParameterFinderArg)
var finder ParameterFinder = f
evaluator.finder = &finder
evaluator.ctx = ctx
evaluator.expression = r.expression
evaluator.specifiedSql = r.specifiedSql
result := evaluator.evaluate()
log.InternalDebug(fmt.Sprintf("Else node %v\n", r.elseNode))
if result {
r.processAcceptingChildren(ctx, loopInfo)
(*ctx).setEnabled(true)
} else if r.elseNode != nil {
// if (loopInfo != null) {
// _elseNode.accept(ctx, loopInfo);
// } else {
var node Node = r.elseNode
r.elseNode.accept(ctx, &node)
// }
}
return
}
func (p *TnCommandContextHandler) Execute(args []interface{}, tx *sql.Tx, behavior *Behavior) interface{} {
p.sql = (*p.CommandContext).getSql()
// fmt.Printf("getBindVariables %v\n",(*p.CommandContext).getBindVariables())
// p.logSql((*p.CommandContext).getBindVariables(),
// (*p.CommandContext).getBindVariableTypes())
// log.Flush()
// fmt.Printf("statementFactory %v \n",p.statementFactory)
bindVariables := (*p.CommandContext).getBindVariables()
bindVariableTypes := (*p.CommandContext).getBindVariableTypes()
dbc := (*(*behavior).GetBaseBehavior().GetBehaviorCommandInvoker().InvokerAssistant).GetDBCurrent()
ps := (*p.statementFactory).PrepareStatement(p.sql, tx, dbc)
defer ps.Close()
bindVar := (*p.statementFactory).ModifyBindVariables(bindVariables, bindVariableTypes)
p.logSql(bindVariables, bindVariableTypes)
log.Flush()
res, err := tx.Stmt(ps).Exec(bindVar.data...)
if err != nil {
panic(err.Error())
}
updateno, _ := res.RowsAffected()
log.InternalDebug(fmt.Sprintln("result no:", updateno))
return updateno
}
func (i *IfCommentEvaluator) processOneProperty(baseObject interface{}, preProperty string, property string) interface{} {
if baseObject == nil {
panic("Null Oblect found:" + preProperty)
}
v := reflect.ValueOf(baseObject).Elem()
log.InternalDebug(fmt.Sprintf("pmb new v %v %T\n", v, v))
newv := v.FieldByName(InitCap(property))
log.InternalDebug(fmt.Sprintf("newv %v \n", newv))
if newv.IsValid() == false {
//どちらが良いか要検討
//return "string", ""
return nil
}
newValue := newv.Interface()
return newValue
}
func (w *BaseConditionKey) BuildBindClause(columnRealName *ColumnRealName,
loc string, co *ConditionOption) *QueryClause {
sqc := CreateStringQueryClause(w.DoBuildBindClause(columnRealName, loc, co))
var qc QueryClause = sqc
log.InternalDebug(fmt.Sprintf(" QueryClause %v \n", qc))
return &qc
}
func (t *TnUpdateEntityDynamicCommand) Execute(args []interface{}, tx *sql.Tx, behavior *Behavior) interface{} {
if args == nil || len(args) == 0 {
panic("The argument 'args' should not be null or empty.")
}
bean := args[0]
var option *UpdateOption = (args[1]).(*UpdateOption)
//未実装
// final UpdateOption<ConditionBean> option = extractUpdateOptionChecked(args);
// prepareStatementConfigOnThreadIfExists(option);
//
// final TnPropertyType[] propertyTypes = createUpdatePropertyTypes(bean, option);
var entity *Entity = bean.(*Entity)
propertyTypes := t.createUpdatePropertyTypes(entity, nil)
if propertyTypes.Size() == 0 {
// if (propertyTypes.length == 0) {
// if (isLogEnabled()) {
// log(createNonUpdateLogMessage(bean));
// }
// return getNonUpdateReturn();
// }
return 1
}
sql := t.createUpdateSql(propertyTypes, option)
log.InternalDebug(fmt.Sprintln("sql :" + sql))
sql2 := t.filterExecutedSql(sql)
return t.doExecute(entity, propertyTypes, sql2, option, tx)
}
func (w *ConditionValue) SetupVaryingValue(cond *ConditionKey, value interface{}) string {
if w.Varying == nil {
log.InternalDebug("Varying created:")
w.Varying = make(map[string]map[string]interface{})
}
key := (*cond).GetConditionKeyS()
log.InternalDebug("GetConditionKeyS :" + key)
var elementMap map[string]interface{} = w.Varying[key]
if elementMap == nil {
elementMap = make(map[string]interface{})
w.Varying[key] = elementMap
}
elementkey := key + strconv.Itoa(len(elementMap))
elementMap[elementkey] = value
return "Varying." + key + "." + elementkey
}
func (o *OutsideSqlSelectExecution) newBasicParameterHandler(executedSql string) *ParameterHandler {
handler := new(TnBasicSelectHandler)
handler.sql = executedSql
handler.statementFactory = o.StatementFactory
log.InternalDebug(fmt.Sprintln("o.ResultType:", o.ResultType))
handler.ResultType = o.ResultType
var hand ParameterHandler = handler
return &hand
}
func (t *TnStatementFactoryImpl) PrepareStatement(orgSql string, tx *sql.Tx,
dbc *DBCurrent) *sql.Stmt {
sql := t.modifySql(orgSql, dbc)
log.InternalDebug(fmt.Sprintf("sql %s \ntx %v %T\n", sql, tx, tx))
stmt, errs := tx.Prepare(sql)
if errs != nil {
panic(errs.Error() + ":" + sql)
}
return stmt
}
func (w *BaseConditionKey) BuildBindClauseOrIsNull(columnRealName *ColumnRealName,
loc string, co *ConditionOption) *QueryClause {
mainQuery := w.DoBuildBindClause(columnRealName, loc, co)
clause := "(" + mainQuery + " or " + columnRealName.ToString() + " is null)"
sqc := new(StringQueryClause)
sqc.Clause = clause
var qc QueryClause = sqc
log.InternalDebug(fmt.Sprintf(" QueryClause %v \n", qc))
return &qc
}
func (w *BaseConditionKey) ResolveBindClause(columnRealName *ColumnRealName,
loc string, co *ConditionOption) *BindClauseResult {
var basicBindExp string
if loc != "" {
basicBindExp = w.BuildBindVariableExp(loc, co)
log.InternalDebug("basicBindExp :" + basicBindExp)
}
resolvedColumn := w.ResolveOptionalColumn(columnRealName, co)
return w.CreateBindClauseResult(resolvedColumn, basicBindExp, co)
}
func (r *RootNode) accept(ctx *CommandContext, node *Node) {
for i := 0; i < r.GetChildSize(); i++ {
inter := r.GetChild(i)
//var node Node = *inter.(*Node)
stype := GetType(*inter)
log.InternalDebug(fmt.Sprintln("accept node type :" + stype))
//node.accept(ctx)
(*inter).accept(ctx, inter)
}
return
}
func (v *ValueAndTypeSetupper) setupValueAndType(valueAndType *ValueAndType) {
value := valueAndType.firstValue
if value == nil { // if null, do nothing
return
}
ctype := valueAndType.firstType
ctype = ctype
// LikeSearchOption handling here is for OutsideSql.
//未実装
var likeSearchOption LikeSearchOption
likeSearchOption = likeSearchOption
//
for pos := 1; pos < v.nameList.Size(); pos++ {
// if (value == null) {
// break;
// }
if value == nil {
break
}
currentName := v.nameList.Get(pos)
ctype, value = getPropertyValue(value, ctype, currentName)
log.InternalDebug(fmt.Sprintf("new ctype %s\n", ctype))
log.InternalDebug(fmt.Sprintf("new value %v\n", value))
if ctype == "map[string]map[string]interface {}" {
var mp map[string]map[string]interface{} = value.(map[string]map[string]interface{})
value = mp[v.nameList.Get(pos+1)][v.nameList.Get(pos+2)]
ctype = GetType(value)
break
}
}
//未実装
//adjustLikeSearchDBWay(likeSearchOption)
// valueAndType.setTargetValue(value);
valueAndType.targetValue = value
log.InternalDebug(fmt.Sprintf("value %v %T\n", value, value))
// valueAndType.setTargetType(clazz);
valueAndType.targetType = ctype
//未実装
// valueAndType.setLikeSearchOption(likeSearchOption);
}
func (w *ConditionValue) SetupNotLikeSearch(value interface{}, location string,
co *ConditionOption) {
if w.NotLikeSearchValueHandler == nil {
var ck ConditionKey = CK_LS
w.NotLikeSearchValueHandler = CreateVaryingValueHandler(w, &ck)
}
var v string = value.(string)
log.InternalDebug("LikeSearch value :" + (*co).GenerateRealValue(v))
w.NotLikeSearchLatestLocation = location + "." +
w.NotLikeSearchValueHandler.SetValue((*co).GenerateRealValue(v))
}
func (b *BaseEntityCommand) getPersistentPropertyNames(
dbmeta *DBMeta) *StringList {
columnInfoList := (*dbmeta).GetColumnInfoList()
propertyNameList := new(StringList)
for _, columnInfo := range columnInfoList.data {
var ci *ColumnInfo = columnInfo.(*ColumnInfo)
propertyNameList.Add(ci.PropertyName)
}
log.InternalDebug(fmt.Sprintf("propertyNameList %v\n",
propertyNameList.data))
return propertyNameList
}
func (t *TnAbstractEntityHandler) setupUpdateBindVariables(entity *Entity) {
// setupUpdateBindVariables(bean);
// これはTnAbstractEntityHandlerで実装
varList := new(List)
varList = varList
varValueTypeList := new(StringList)
varValueTypeList = varValueTypeList
timestampPropertyName := ""
timestampPropertyName = timestampPropertyName
versionNoPropertyName := ""
if (*(*entity).GetDBMeta()).HasVersionNo() {
versionNoPropertyName = (*(*entity).GetDBMeta()).GetVersionNoColumnInfo().PropertyName
}
versionNoPropertyName = versionNoPropertyName
for _, ptx := range t.boundPropTypes.data {
var pt *TnPropertyType = ptx.(*TnPropertyType)
pt = pt
log.InternalDebug(fmt.Sprintf("PT %v\n", pt))
//未実装
// if (pt.getPropertyName().equalsIgnoreCase(timestampPropertyName)) {
// final Timestamp timestamp = ResourceContext.getAccessTimestamp();
// addNewTimestamp(timestamp);
// varList.add(timestamp);
// } else if (pt.getPropertyName().equalsIgnoreCase(versionNoPropertyName)) {
if pt.propetyName == versionNoPropertyName {
if !t.versionNoAutoIncrementOnMemory { // means OnQuery
continue // because of 'VERSION_NO = VERSION_NO + 1'
}
var versionNo int64 = *(GetEntityValue(entity, versionNoPropertyName).(*int64)) + 1
// final Object value = pt.getPropertyDesc().getValue(bean); // already null-checked
// final long longValue = DfTypeUtil.toPrimitiveLong(value) + 1L;
// final Long versionNo = Long.valueOf(longValue);
if t.newVersionNoList == nil {
t.newVersionNoList = new(List)
}
t.newVersionNoList.Add(versionNo)
varList.Add(versionNo)
// } else if (_updateOption != null && _updateOption.hasStatement(pt.getColumnDbName())) {
// continue; // because of 'FOO_COUNT = FOO_COUNT + 1'
} else {
varList.Add(GetEntityValue(entity, pt.propetyName))
}
varValueTypeList.Add(pt.GoType)
// }
}
t.addAutoUpdateWhereBindVariables(varList, varValueTypeList, entity)
t.bindVariables = varList
t.bindVariableValueTypes = varValueTypeList
}
func (s *SqlAnalyzer) isElseMode() bool {
// 未実装
// for (int i = 0; i < _nodeStack.size(); ++i) {
// if (_nodeStack.get(i) instanceof ElseNode) {
// return true;
// }
// }
for _, node := range s.stack.data {
n := node.(*Node)
log.InternalDebug(fmt.Sprintf("nodetype %v %s\n", node, (*n).stype()))
}
return false
}
func (t *TnAbstractEntityStaticCommand) setupDeleteSql() {
// checkPrimaryKey();
// final StringBuilder sb = new StringBuilder(64);
// sb.append("delete from ").append(_targetDBMeta.getTableSqlName());
// setupDeleteWhere(sb);
// _sql = sb.toString();
sb := new(bytes.Buffer)
sb.WriteString("delete from " + (*t.targetDBMeta).GetTableDbName())
t.setupDeleteWhere(sb)
t.sql = sb.String()
log.InternalDebug(t.sql)
return
}
func (t *TnAbstractTwoWaySqlCommand) Execute(args []interface{}, tx *sql.Tx, behavior *Behavior) interface{} {
log.InternalDebug("TnAbstractTwoWaySqlCommand Execute")
//Current
// final Node rootNode = getRootNode(args);
rootNode := (*t.sqlExecution).GetRootNode(args)
ctx := t.apply(rootNode, args, (*t.sqlExecution).GetArgNames(), (*t.sqlExecution).GetArgTypes())
log.InternalDebug("ctx Sql :" + (*ctx).getSql())
executedSql := (*t.sqlExecution).filterExecutedSql((*ctx).getSql())
log.InternalDebug("executedSql :" + executedSql)
handler := t.createBasicParameterHandler(ctx, executedSql)
//fmt.Printf("handler %v %T\n", handler, handler)
//fmt.Printf("behavior %v %T\n", behavior, behavior)
bindVariables := (*ctx).getBindVariables()
log.InternalDebug(fmt.Sprintf("bind Variables %v \n", bindVariables))
bindVariableTypes := (*ctx).getBindVariableTypes()
bindVariables = bindVariables
bindVariableTypes = bindVariableTypes
rtn := (*handler).execute(bindVariables, bindVariableTypes, tx, behavior)
// return filterReturnValue(handler.execute(bindVariables, bindVariableTypes));
return rtn
}
func (s *SqlAnalyzer) Analyze() *Node {
// push(createRootNode()); // root node of all
rn := s.CreateRootNode()
log.InternalDebug(fmt.Sprintf("AnalyzeRoot Node %v\n", rn))
var node Node = rn
s.Push(&node)
// while (SqlTokenizer.EOF != _tokenizer.next()) {
//for TOK_EOF != s.tokenizer.Next() {
for {
res := s.tokenizer.Next()
if res == TOK_EOF {
break
}
s.parseToken()
}
// parseToken();
// }
// return pop();
res := s.Pop()
log.InternalDebug(fmt.Sprintf("AnalyzeRoot End Node %v\n", res))
return res
}
func (b *BaseConditionQuery) ToColumnRealName(
col string, csn *ColumnSqlName) *ColumnRealName {
var crn *ColumnRealName
if csn != nil {
crn = CreateColumnRealName(b.AliasName, csn)
} else {
dbmeta := b.xgetLocalDBMeta()
log.InternalDebug(fmt.Sprintf("ToColumnRealName dbmeta %v \n", dbmeta))
cno := (*dbmeta).GetColumnInfoMap()[col]
ci := (*dbmeta).GetColumnInfoList().Get(cno)
columnInfo := ci.(*ColumnInfo)
crn = CreateColumnRealName(b.AliasName, columnInfo.ColumnSqlName)
}
return crn
}
func (b *BaseBehavior) injectSequenceToPrimaryKeyIfNeeds(entity *Entity,
tx *sql.Tx) {
dbmeta := (*entity).GetDBMeta()
if !(*dbmeta).HasSequence() || (*dbmeta).HasCompoundPrimaryKey() ||
(*entity).HasPrimaryKeyValue() || (*dbmeta).HasIdentity() {
return
}
// basically property(column) type is same as next value type
// so there is NOT type conversion cost when writing to the entity
col := ((*dbmeta).GetPrimaryUniqueInfo().UniqueColumnList.Get(0)).(*ColumnInfo)
nextVal := (*b.Behavior).ReadNextVal(tx)
log.InternalDebug("next val " + fmt.Sprintf("%v", nextVal))
SetEntityValue(entity, col.PropertyName, nextVal)
return
}
func (r *VariableNode) doAcceptSub(ctx *CommandContext, firstValue interface{}, firstType string, loopInfo *LoopInfo, inheritLoop bool, node *Node) {
// assertInLoopOnlyOptionInLoop(loopInfo);
valueAndType := new(ValueAndType)
valueAndType.firstValue = firstValue
valueAndType.firstType = firstType
r.setupValueAndType(valueAndType, node)
//未実装
// processLikeSearch(valueAndType, loopInfo, inheritLoop);
log.InternalDebug(fmt.Sprintf("blockNullParameter %v \n ", r.blockNullParameter))
if r.blockNullParameter && IsNotNull(valueAndType.targetValue) == false {
panic("The value of bind variable was null.")
}
(*node).doProcess(ctx, valueAndType, loopInfo)
return
}
func (b *BaseConditionQuery) SetupConditionValueAndRegisterWhereClauseSub(
key *ConditionKey, value interface{}, cvalue *ConditionValue,
col string, co *ConditionOption) {
dm := b.DBMetaProvider.TableDbNameInstanceMap[b.TableDbName]
cinfo := (*dm).GetColumnInfoByPropertyName(col)
pn := cinfo.PropertyName
un := InitUnCap(pn)
loc := b.XgetLocation(un)
log.InternalDebug(fmt.Sprintln("Location :" + loc))
(*key).SetupConditionValue(
key, b.XcreateQueryModeProvider(), cvalue, value, loc, co)
crn := b.ToColumnRealName(col, cinfo.ColumnSqlName)
usedAliasName := b.AliasName
(*b.SqlClause).RegisterWhereClause(crn, key, cvalue, co, usedAliasName)
}
func (t *TnAbstractEntityHandler) setupInsertBindVariables(entity *Entity) {
// setupInsertBindVariables(bean);
// これはTnAbstractEntityHandlerで実装
varList := new(List)
varList = varList
varValueTypeList := new(StringList)
varValueTypeList = varValueTypeList
timestampPropertyName := ""
timestampPropertyName = timestampPropertyName
versionNoPropertyName := ""
if (*(*entity).GetDBMeta()).HasVersionNo() {
versionNoPropertyName = (*(*entity).GetDBMeta()).GetVersionNoColumnInfo().PropertyName
}
versionNoPropertyName = versionNoPropertyName
//fmt.Printf("boundPropTypes %d\n",t.boundPropTypes.Size())
for _, ptx := range t.boundPropTypes.data {
var pt *TnPropertyType = ptx.(*TnPropertyType)
pt = pt
log.InternalDebug(fmt.Sprintf("PT %v\n", pt))
//未実装
// if (pt.getPropertyName().equalsIgnoreCase(timestampPropertyName)) {
// final Timestamp timestamp = ResourceContext.getAccessTimestamp();
// addNewTimestamp(timestamp);
// varList.add(timestamp);
// } else if (pt.getPropertyName().equalsIgnoreCase(versionNoPropertyName)) {
//fmt.Printf("propetyName %s versionNoPropertyName %s\n", pt.propetyName, versionNoPropertyName)
if pt.propetyName == versionNoPropertyName {
var firstNo int64 = VERSION_NO_FIRST_VALUE
if t.newVersionNoList == nil {
t.newVersionNoList = new(List)
}
t.newVersionNoList.Add(firstNo)
varList.Add(firstNo)
//fmt.Printf("version no %d propetyName %s\n", firstNo, pt.propetyName)
} else {
varList.Add(GetEntityValue(entity, pt.propetyName))
}
varValueTypeList.Add(pt.GoType)
// }
}
t.bindVariables = varList
t.bindVariableValueTypes = varValueTypeList
//fmt.Printf("varList size %d %v\n",varList.Size(),varList)
//fmt.Printf("varValueTypeList size %d\n",varValueTypeList.Size())
}
func (t *TnInsertEntityDynamicCommand) createInsertPropertyTypes(entity *Entity, option *InsertOption) *List {
propetyNames := new(StringList)
//dbMeta := (*entity).GetDBMeta()
modifiedSet := t.getModifiedPropertyNames(entity)
//fmt.Printf("ModifiedSet %v\n", modifiedSet)
typeList := new(List)
timestampProp := ""
timestampProp = timestampProp
versionNoProp := ""
if (*(*entity).GetDBMeta()).HasVersionNo() {
versionNoProp = (*(*entity).GetDBMeta()).GetVersionNoColumnInfo().PropertyName
versionNoProp = versionNoProp
}
primaryKeyset := make(map[string]string)
primaryKeyset = primaryKeyset
if (*(*entity).GetDBMeta()).HasPrimaryKey() {
primaryKeys := (*(*entity).GetDBMeta()).GetPrimaryInfo().UniqueInfo.UniqueColumnList.data
for _, primaryKey := range primaryKeys {
var colInfo *ColumnInfo = primaryKey.(*ColumnInfo)
primaryKeyset[colInfo.PropertyName] = colInfo.PropertyName
}
}
for _, propertyName := range t.propertyNames.data {
_, ok := primaryKeyset[propertyName]
if ok {
if option == nil || !option.isPrimaryKeyIdentityDisabled() {
if (*(*entity).GetDBMeta()).HasIdentity() {
continue
}
}
typeList.Add((*(*entity).GetDBMeta()).GetPropertyType(propertyName))
propetyNames.Add(propertyName)
continue
}
log.InternalDebug(fmt.Sprintf("propertyName %v\n", propertyName))
//pt:=(*dbMeta).GetPropertyType(propertyName)
if t.isOptimisticLockProperty(timestampProp, versionNoProp, propertyName) || t.isSpecifiedProperty(option, modifiedSet, propertyName) {
// Statement
typeList.Add((*(*entity).GetDBMeta()).GetPropertyType(propertyName))
propetyNames.Add(propertyName)
//fmt.Println("typeList Added :" + propertyName)
}
}
t.propertyNames = propetyNames
return typeList
}