ASN1ObjectIdentifier oid = testOid();
            MIEName a = new MIEName(oid, "Alice");
            MIEName b = new MIEName(oid, "alice");
            assertEquals(a, b);
            assertEquals(a.hashCode(), b.hashCode());
        }

        @Test
        void equalsHandlesNullNames() {
            ASN1ObjectIdentifier oid = testOid();
            MIEName a = new MIEName(oid, null);

			for idx, name := range db.Statement.Selects {
				if db.Statement.Schema == nil {
					clauseSelect.Columns[idx] = clause.Column{Name: name, Raw: true}
				} else if f := db.Statement.Schema.LookUpField(name); f != nil {
					clauseSelect.Columns[idx] = clause.Column{Name: f.DBName}
				} else {
					clauseSelect.Columns[idx] = clause.Column{Name: name, Raw: true}
				}
			}

        int idx = 0;
        SMBUtil.writeInt2(transformCount, data, idx);
        idx += 2;
        SMBUtil.writeInt2(reserved1, data, idx);
        idx += 2;
        SMBUtil.writeInt4(reserved2, data, idx);
        idx += 4;

        // SMB_DIRECT_RDMA_TRANSFORM array (only one element)
        SMBUtil.writeInt2(rdmaTransformId, data, idx);
        idx += 2;

        }

        int idx = 0;
        String u = url;
        if (u.startsWith("https:") || u.startsWith("http:")) {
            idx = u.lastIndexOf('?');
            if (idx >= 0) {
                u = u.substring(0, idx);
            }

            idx = u.lastIndexOf('#');
            if (idx >= 0) {
                u = u.substring(0, idx);
            }
        }

	var (
		afterParenthesis bool
		idx              int
	)

	for _, v := range []byte(expr.SQL) {
		if v == '?' && len(expr.Vars) > idx {
			if afterParenthesis || expr.WithoutParentheses {
				if _, ok := expr.Vars[idx].(driver.Valuer); ok {
					builder.AddVar(builder, expr.Vars[idx])
				} else {
					switch rv := reflect.ValueOf(expr.Vars[idx]); rv.Kind() {
					case reflect.Slice, reflect.Array:

    // idx = 2 -> :method: GET
    bytesIn.writeByte(0x86) // == Indexed - Add ==
    // idx = 6 -> :scheme: http
    bytesIn.writeByte(0x84) // == Indexed - Add ==
    // idx = 4 -> :path: /
    bytesIn.writeByte(0xbe) // == Indexed - Add ==
    // idx = 62 -> :authority: www.example.com
    bytesIn.writeByte(0x58) // == Literal indexed ==
    // Indexed name (idx = 24) -> cache-control

						}

						hasParity := 0
						parityOK := make([]bool, m.shards)
						for idx, sh := range v {
							splitData[idx] = sh
							if idx >= k && len(sh) > 0 {
								parityOK[idx] = true
								hasParity++
								for i := range splitFilled[idx] {
									splitFilled[idx][i] = 1
								}
							}
						}

						splitDataShards := make([]byte, len(splitFilled[0]))

    }

    /**
     * Gets the selected authentication mechanism OID
     * @return the mechanism OID
     */
    public ASN1ObjectIdentifier getMechanism() {
        return this.mechanism;
    }

    /**
     * Sets the selected authentication mechanism OID
     * @param mechanism the mechanism OID to set
     */
    public void setMechanism(final ASN1ObjectIdentifier mechanism) {

			where.Exprs = andCondition.Exprs
		}
	}

	// Switch position if the first query expression is a single Or condition
	for idx, expr := range where.Exprs {
		if v, ok := expr.(OrConditions); !ok || len(v.Exprs) > 1 {
			if idx != 0 {
				where.Exprs[0], where.Exprs[idx] = where.Exprs[idx], where.Exprs[0]
			}
			break
		}
	}

	buildExprs(where.Exprs, builder, AndWithSpace)
}

			if r != rel && r.FieldSchema == rel.Schema && len(rel.References) == len(r.References) {
				matched := true
				for idx, ref := range r.References {
					if !(rel.References[idx].PrimaryKey == ref.PrimaryKey && rel.References[idx].ForeignKey == ref.ForeignKey &&
						rel.References[idx].PrimaryValue == ref.PrimaryValue) {
						matched = false
						break
					}
				}

				if matched {
					return nil