checkSpecifiedProperty("value");
        return convertEmptyToNull(value);
    }

    public void setValue(String value) {
        registerModifiedProperty("value");
        this.value = value;
    }

        is Short -> KaConstantValue.KaShortConstantValue(value, expression)
        is UShort -> KaConstantValue.KaUnsignedShortConstantValue(value, expression)
        is Int -> KaConstantValue.KaIntConstantValue(value, expression)
        is UInt -> KaConstantValue.KaUnsignedIntConstantValue(value, expression)
        is Long -> KaConstantValue.KaLongConstantValue(value, expression)

import javax.annotation.Nullable;

/**
 * A {@link PropertyValue} backed by a fixed value.
 */
public class StaticValue implements PropertyValue {
    private final Object value;

    public StaticValue(@Nullable Object value) {
        this.value = value;
    }

    public static PropertyValue of(@Nullable Object value) {
        return new StaticValue(value);
    }

    @Override

        outputStream.writeFloat(value);
    }

    @Override
    public void writeDouble(double value) throws IOException {
        outputStream.writeDouble(value);
    }

    @Override
    public void writeBoolean(boolean value) throws IOException {
        outputStream.writeBoolean(value);
    }

    @Override
    public void writeString(CharSequence value) throws IOException {
        if (value == null) {

}

// Any returns an Attr for the supplied value.
// See [AnyValue] for how values are treated.
func Any(key string, value any) Attr {
	return Attr{key, AnyValue(value)}
}

// Equal reports whether a and b have equal keys and values.
func (a Attr) Equal(b Attr) bool {
	return a.Key == b.Key && a.Value.Equal(b.Value)
}

func (a Attr) String() string {
	return a.Key + "=" + a.Value.String()
}

    public void writeInt(int value) {
        output.writeInt(value);
    }

    @Override
    public void writeSmallInt(int value) {
        output.writeInt(value, true);
    }

    @Override
    public void writeShort(short value) throws IOException {
        output.writeShort(value);
    }

    @Override
    public void writeFloat(float value) throws IOException {
        output.writeFloat(value);
    }

			}},
			"SELECT * FROM `users` WHERE `users`.`id` = ? OR `name` <> ? AND `age` > ?",
			[]interface{}{"1", "jinzhu", 18},
		},
		{
			[]clause.Interface{clause.Select{}, clause.From{}, clause.Where{

				}
			}
		case reflect.Struct:
			for _, field := range stmt.Schema.PrimaryFields {
				if value, isZero := field.ValueOf(stmt.Context, stmt.ReflectValue); !isZero {
					stmt.AddClause(clause.Where{Exprs: []clause.Expression{clause.Eq{Column: field.DBName, Value: value}}})
				}
			}
		}
	}

	switch value := updatingValue.Interface().(type) {

        e.message == 'Cannot query the value of this provider because it has no value available.'
    }

    def "toString() displays nice things"() {
        expect:
        new TestProvider().toString() == "provider(java.lang.String)"
    }

    static class TestProvider extends AbstractMinimalProvider {
        @Nullable
        String value

        void value(String s) {
            this.value = s

        }
        Object value = unpackNestableDeferred(deferred);
        if (value instanceof Provider) {
            return providerResolutionStrategy.resolve((Provider<?>) value);
        }
        if (value instanceof Factory) {
            return ((Factory<?>) value).create();
        }
        return value;
    }

    public static boolean isDeferred(Object value) {
        return value instanceof Provider