},
	}

	for _, testCase := range testCases {
		testCase := testCase
		t.Run("", func(t *testing.T) {
			tmpfile, err := os.CreateTemp("", "testfile")
			if err != nil {
				t.Error(err)
			}
			tmpfile.WriteString(testCase.content)
			tmpfile.Sync()
			tmpfile.Close()

			value, err := readFromSecret(tmpfile.Name())
			if err != nil && !testCase.expectedErr {
				t.Error(err)
			}

			}
			builder.WriteQuoted(column)
		}
		builder.WriteByte(')')

		builder.WriteString(" VALUES ")

		for idx, value := range values.Values {
			if idx > 0 {
				builder.WriteByte(',')
			}

			builder.WriteByte('(')
			builder.AddVar(builder, value...)
			builder.WriteByte(')')
		}
	} else {
		builder.WriteString("DEFAULT VALUES")
	}
}

// MergeClause merge values clauses

	err = en.Append(0xa4, 0x50, 0x61, 0x74, 0x68)
	if err != nil {
		return
	}
	err = en.WriteString(z.Path)
	if err != nil {
		err = msgp.WrapError(err, "Path")
		return
	}
	// write "Endpoint"
	err = en.Append(0xa8, 0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74)
	if err != nil {
		return
	}
	err = en.WriteString(z.Endpoint)
	if err != nil {
		err = msgp.WrapError(err, "Endpoint")
		return
	}

		return
	}
	for za0001, za0002 := range z.Entries {
		err = en.WriteString(za0001)
		if err != nil {
			err = msgp.WrapError(err, "Entries")
			return
		}
		// map header, size 3
		// write "b"
		err = en.Append(0x83, 0xa1, 0x62)
		if err != nil {
			return
		}
		err = en.WriteString(za0002.Bucket)
		if err != nil {
			err = msgp.WrapError(err, "Entries", za0001, "Bucket")

	if err != nil {
		err = msgp.WrapError(err, "Num")
		return
	}
	// write "String"
	err = en.Append(0xa6, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67)
	if err != nil {
		return
	}
	err = en.WriteString(z.String)
	if err != nil {
		err = msgp.WrapError(err, "String")
		return
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z testRequest) MarshalMsg(b []byte) (o []byte, err error) {

	// write "Type"
	err = en.Append(0x83, 0xa4, 0x54, 0x79, 0x70, 0x65)
	if err != nil {
		return
	}
	err = en.WriteString(string(z.Type))
	if err != nil {
		err = msgp.WrapError(err, "Type")
		return
	}
	// write "Key"
	err = en.Append(0xa3, 0x4b, 0x65, 0x79)
	if err != nil {
		return
	}
	err = en.WriteString(z.Key)
	if err != nil {
		err = msgp.WrapError(err, "Key")
		return
	}
	// write "Context"

		if err != nil {
			err = msgp.WrapError(err, "Checksums")
			return
		}
		for za0001, za0002 := range z.Checksums {
			err = en.WriteString(za0001)
			if err != nil {
				err = msgp.WrapError(err, "Checksums")
				return
			}
			err = en.WriteString(za0002)
			if err != nil {
				err = msgp.WrapError(err, "Checksums", za0001)
				return
			}
		}
	}
	return
}

	} else {
		for idx, column := range orderBy.Columns {
			if idx > 0 {
				builder.WriteByte(',')
			}

			builder.WriteQuoted(column.Column)
			if column.Desc {
				builder.WriteString(" DESC")
			}
		}
	}
}

// MergeClause merge order by clauses
func (orderBy OrderBy) MergeClause(clause *Clause) {
	if v, ok := clause.Expression.(OrderBy); ok {

            }
            else {
                // plain text
                this.password = new byte[ ( pwAuth.getPassword().length() + 1 ) * 2];
                this.passwordLength = writeString(pwAuth.getPassword(), this.password, 0);
            }
        }
        else {
            // no password in tree connect
            this.passwordLength = 1;
        }

func (z localLockMap) EncodeMsg(en *msgp.Writer) (err error) {
	err = en.WriteMapHeader(uint32(len(z)))
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0006, zb0007 := range z {
		err = en.WriteString(zb0006)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		err = en.WriteArrayHeader(uint32(len(zb0007)))
		if err != nil {
			err = msgp.WrapError(err, zb0006)
			return
		}