func ConvertMapToValuesForCreate(stmt *gorm.Statement, mapValue map[string]interface{}) (values clause.Values) {
	values.Columns = make([]clause.Column, 0, len(mapValue))
	selectColumns, restricted := stmt.SelectAndOmitColumns(true, false)

	keys := make([]string, 0, len(mapValue))
	for k := range mapValue {
		keys = append(keys, k)
	}
	sort.Strings(keys)

	for _, k := range keys {
		value := mapValue[k]
		if stmt.Schema != nil {

	"k8s.io/apiserver/pkg/cel"
)

type GetFieldFunc func(*MapValue) ref.Val

var _ ref.Val = (*MapValue)(nil)
var _ traits.Mapper = (*MapValue)(nil)

// MapValue is a map that lazily evaluate its value when a field is first accessed.
// The map value is not designed to be thread-safe.
type MapValue struct {
	typeValue *types.Type

	// values are previously evaluated values obtained from callbacks

func Sort(mapValue reflect.Value) SortedMap {
	if mapValue.Type().Kind() != reflect.Map {
		return nil
	}
	// Note: this code is arranged to not panic even in the presence
	// of a concurrent map update. The runtime is responsible for
	// yelling loudly if that happens. See issue 33275.
	n := mapValue.Len()
	sorted := make(SortedMap, 0, n)
	iter := mapValue.MapRange()
	for iter.Next() {

	activation := &testActivation{variables: variablesMap}

	// add foo as a string
	variablesType.Fields["foo"] = apiservercel.NewDeclField("foo", apiservercel.StringType, true, nil, nil)
	variablesMap.Append("foo", func(_ *MapValue) ref.Val {
		return types.String("foo-string")
	})

	exp := "variables.foo == 'foo-string'"
	v, err := compileAndRun(env, activation, exp)
	if err != nil {
		t.Fatalf("%q: %v", exp, err)
	}

            }

            return ExecutionTimeValue.value(mapValue(context, value.toValue()));
        }
    }

    @Nonnull
    @Override
    protected Value<OUT> mapValue(EvaluationContext.ScopeContext context, Value<? extends IN> value) {
        Value<OUT> transformedValue = super.mapValue(context, value);
        // Check MappingProvider contract with regard to the transform

            return ExecutionTimeValue.value(mapValue(context, value.toValue()));
        }
    }

    @Override
    protected Value<? extends OUT> calculateOwnValue(ValueConsumer consumer) {
        try (EvaluationContext.ScopeContext context = openScope()) {
            beforeRead(context);
            Value<? extends IN> value = provider.calculateValue(consumer);
            return mapValue(context, value);
        }
    }

import "C"

var x = map[C.jobject]int{nil: 0}
`,
		Out: `package main

// typedef struct _jobject* jobject;
import "C"

var x = map[C.jobject]int{0: 0}
`,
	},
	{
		Name: "jni.MapValue",
		In: `package main

// typedef struct _jobject* jobject;
import "C"

var x = map[int]C.jobject{0: nil}
`,
		Out: `package main

// typedef struct _jobject* jobject;
import "C"

import "C"

var x = map[C.$EGLTYPE]int{nil: 0}
`,
			Out: `package main

// typedef void *$EGLTYPE;
import "C"

var x = map[C.$EGLTYPE]int{0: 0}
`,
		},
		{
			Name: "egl.MapValue",
			In: `package main

// typedef void *$EGLTYPE;
import "C"

var x = map[int]C.$EGLTYPE{0: nil}
`,
			Out: `package main

// typedef void *$EGLTYPE;
import "C"

import "C"

var x = map[C.CFTypeRef]int{nil: 0}
`,
		Out: `package main

// typedef const void *CFTypeRef;
import "C"

var x = map[C.CFTypeRef]int{0: 0}
`,
	},
	{
		Name: "cftype.MapValue",
		In: `package main

// typedef const void *CFTypeRef;
import "C"

var x = map[int]C.CFTypeRef{0: nil}
`,
		Out: `package main

// typedef const void *CFTypeRef;
import "C"

            ? 'getInputs().property("input", "value");'
            : ""}
                    Map<String, Object> mapValues = new HashMap<String, Object>();
                    mapValues.put("mapInput", "mapValue");
                    ${previousVersionLeaksInternal ? "((TaskInputs)getInputs())" : "getInputs()"}.properties(mapValues);
                }

                @TaskAction
                public void doGet() {