}

        final Smb2NegotiateResponse resp = (Smb2NegotiateResponse) this.negotiated;
        final DialectVersion dialect = resp.getSelectedDialect();
        int cipherId = -1;

        if (dialect.atLeast(DialectVersion.SMB311)) {
            cipherId = resp.getSelectedCipher();
            if (cipherId == -1) {

            this.nativeOs = value;
        }

        value = props.getProperty("jcifs.smb.client.nativeLanMan");
        if (value != null) {
            this.nativeLanMan = value;
        }

        // Dialect version properties - these should throw exceptions for invalid values
        String minVersion = props.getProperty("jcifs.smb.client.minVersion");
        String maxVersion = props.getProperty("jcifs.smb.client.maxVersion");

    @Override
    public boolean canReuse(final CIFSContext tc, final boolean forceSigning) {
        return this.getConfig().equals(tc.getConfig());
    }

    /**
     * Returns the index of the selected SMB dialect from the negotiation.
     *
     * @return the dialectIndex
     */
    public int getDialectIndex() {
        return this.dialectIndex;
    }

    /**

	callbackTypeBeforeDelete, callbackTypeAfterDelete,
	callbackTypeAfterFind,
}

// Parse get data type from dialector
func Parse(dest interface{}, cacheStore *sync.Map, namer Namer) (*Schema, error) {
	return ParseWithSpecialTableName(dest, cacheStore, namer, "")
}

// ParseWithSpecialTableName get data type from dialector with extra schema table

			sql, vars := stmt.SQL.String(), stmt.Vars
			if filter, ok := db.Logger.(ParamsFilter); ok {
				sql, vars = filter.ParamsFilter(stmt.Context, stmt.SQL.String(), stmt.Vars...)
			}
			return db.Dialector.Explain(sql, vars...), db.RowsAffected
		}, db.Error)
	}

	if !stmt.DB.DryRun {
		stmt.SQL.Reset()
		stmt.Vars = nil
	}

	if resetBuildClauses {
		stmt.BuildClauses = nil
	}

											vars := onStmt.Vars
											for idx, v := range vars {
												bindvar := strings.Builder{}
												onStmt.Vars = vars[0 : idx+1]
												db.Dialector.BindVarTo(&bindvar, &onStmt, v)
												onSQL = strings.Replace(onSQL, bindvar.String(), "?", 1)
											}

											exprs = append(exprs, clause.Expr{SQL: onSQL, Vars: vars})
										}
									}

	AssociationEmptyUserID *uint  `gorm:"uniqueIndex:uniq_user_id_name"`
	Name                   string `gorm:"uniqueIndex:uniq_user_id_name;size:256"`
}

func TestAssociationEmptyPrimaryKey(t *testing.T) {
	if DB.Dialector.Name() != "mysql" {
		t.Skip()
	}
	DB.Migrator().DropTable(&AssociationEmptyUser{}, &AssociationEmptyPet{})
	DB.AutoMigrate(&AssociationEmptyUser{}, &AssociationEmptyPet{})

	id := uint(100)

			db.AddError(committer.Rollback())
		}
	} else {
		db.AddError(ErrInvalidTransaction)
	}
	return db
}

func (db *DB) SavePoint(name string) *DB {
	if savePointer, ok := db.Dialector.(SavePointerDialectorInterface); ok {
		// close prepared statement, because SavePoint not support prepared statement.
		// e.g. mysql8.0 doc: https://dev.mysql.com/doc/refman/8.0/en/sql-prepared-statements.html
		var (

            negotiate(altPort, resp);
            port = altPort;
        }

        if (resp.dialectIndex > 10) {
            throw new SmbException("This client does not support the negotiated dialect.");
        }
        if ((server.capabilities & CAP_EXTENDED_SECURITY) != CAP_EXTENDED_SECURITY && server.encryptionKeyLength != 8
                && LM_COMPATIBILITY == 0) {

	}

	var result Language
	if err := DB.Find(&result, "code = ?", lang.Code).Error; err != nil || result.Name != lang.Name {
		t.Fatalf("failed to upsert, got name %v", result.Name)
	}

	if name := DB.Dialector.Name(); name != "sqlserver" {
		type RestrictedLanguage struct {
			Code string `gorm:"primarykey"`
			Name string
			Lang string `gorm:"<-:create"`
		}