}

// Comment returns the comment of current column.
func (ct ColumnType) Comment() (value string, ok bool) {
	return ct.CommentValue.String, ct.CommentValue.Valid
}

// DefaultValue returns the default value of current column.
func (ct ColumnType) DefaultValue() (value string, ok bool) {
	return ct.DefaultValueValue.String, ct.DefaultValueValue.Valid

     * @param name the property name
     * @param defaultValue the default value to use if property doesn't exist
     * @param appendValue the value to append to the property value
     */
    protected void addSystemProperty(final List<String> cmdList, final String name, final String defaultValue, final String appendValue) {
        final String value = System.getProperty(name);

          <version>1.1.0+</version>
          <defaultValue>self-first</defaultValue>
          <required>false</required>
          <type>String</type>
        </field>
        <field>
          <name>configuration</name>
          <version>1.2.0+</version>

          <version>1.0.0</version>
          <name>editable</name>
          <description>Whether the value of this expression can be changed.</description>
          <type>boolean</type>
          <defaultValue>true</defaultValue>
        </field>
      </fields>
    </class>
  </classes>

      if (isNullable(param)) {
        args.add(null);
        continue;
      }
      Object defaultValue = getDummyValue(param.getType());
      if (defaultValue == null) {
        throw new ParameterNotInstantiableException(param);
      }
      args.add(defaultValue);
    }
    return args;
  }

  private <T> @Nullable T getDummyValue(TypeToken<T> type) {

        FessConfig fessConfig = new FessConfig.SimpleImpl() {
            @Override
            public String getSystemProperty(final String key, final String defaultValue) {
                return systemPropMap.getOrDefault(key, defaultValue);
            }
        };
        ComponentUtil.setFessConfig(fessConfig);
        SystemHelper systemHelper = new SystemHelper() {
            @Override

			case schema.Time:
				if !strings.EqualFold(strings.TrimSuffix(dv, "()"), strings.TrimSuffix(field.DefaultValue, "()")) {
					alterColumn = true
				}
			case schema.Bool:
				v1, _ := strconv.ParseBool(dv)
				v2, _ := strconv.ParseBool(field.DefaultValue)
				alterColumn = v1 != v2
			default:
				alterColumn = dv != field.DefaultValue
			}
		}
	}

	// check comment

         * @param key The property key to look up
         * @param defaultValue The default value to return if the property is not set
         * @return The property value or the default value
         */
        protected String getProperty(final String key, final String defaultValue) {
            return ComponentUtil.getSystemProperties().getProperty(key, defaultValue);
        }

        /**

        return parent.hashCode();
    }

    @Override
    public V getOrDefault(final Object key, final V defaultValue) {
        final V value = parent.get(key);
        if (value != null) {
            return value;
        }
        return parent.getOrDefault(toCamelCase(key), defaultValue);
    }

    @Override
    public void forEach(final BiConsumer<? super K, ? super V> action) {

			},
		},
		ReflectValue: reflect.ValueOf(dest),
		Dest:         dest,
	}

	stmt.Schema = s

	values := ConvertToCreateValues(stmt)
	expected := clause.Values{
		// column has value + defaultValue column has value (which should have a stable order)
		Columns: []clause.Column{{Name: "name"}, {Name: "email"}, {Name: "age"}, {Name: "id"}},
		Values: [][]interface{}{
			{"alice", "email", 18, 1},
			{"bob", "email", 19, 2},