},
			}},
			References: []Reference{{"ID", "User", "UserID", "user_friends", "", true}, {"ID", "User", "FriendID", "user_friends", "", false}},
		},
	}

	for _, relation := range relations {
		checkSchemaRelation(t, user, relation)
	}
}

func TestParseSchemaWithAdvancedDataType(t *testing.T) {
	user, err := schema.Parse(&AdvancedDataTypeUser{}, &sync.Map{}, schema.NamingStrategy{})
	if err != nil {

						} else {
							db.AddError(fmt.Errorf("relation %s not found", association))
							return nil
						}
					}
				} else {
					db.AddError(fmt.Errorf("relation %s not found", association))
					return nil
				}
			}

			if q.limitPerRecord > 0 {
				if relation.JoinTable != nil {
					tx.AddError(fmt.Errorf("many2many relation %s don't support LimitPerRecord", association))
					return tx

import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.apache.lucene.search.TotalHits.Relation;
import org.codelibs.core.collection.ArrayUtil;
import org.codelibs.core.concurrent.CommonPoolUtil;
import org.codelibs.core.lang.StringUtil;
import org.codelibs.core.stream.StreamUtil;
import org.codelibs.fess.Constants;

						aliasName := utils.JoinNestedRelationNames(names[0 : len(names)-1])
						for _, join := range db.Statement.Joins {
							if join.Alias == aliasName {
								names = append(strings.Split(join.Name, "."), names[len(names)-1])
								break
							}
						}

						if rel, ok := sch.Relationships.Relations[names[0]]; ok {
							subNameCount := len(names)

# additionalForeignKeyMap: (NotRequired - Default map:{})
#
# If foreign key does not exist in your database,
# you can set up here as virtual foreign key for DBFlute.
#
# And it's one-to-one relation if you add one fixed condition to referrer table, 
# you can set virtual foreign key with fixedCondition and fixedSuffix.
# And you can use it to view objects too.
#
# If local column name is same as foreign column name,

						if reflect.Indirect(obj).Kind() != reflect.Struct {
							break
						}
						if _, zero := rel.Field.ValueOf(db.Statement.Context, obj); !zero { // check belongs to relation value
							rv := rel.Field.ReflectValueOf(db.Statement.Context, obj) // relation reflect value
							if !isPtr {
								rv = rv.Addr()
							}
							objs = append(objs, obj)
							elems = reflect.Append(elems, rv)

     *
     * @return the total record count
     */
    public long getAllRecordCount() {
        return allRecordCount;
    }

    /**
     * Gets the relation type for the total record count.
     *
     * @return the relation type (e.g., "eq" for exact count, "gte" for greater than or equal)
     */
    public String getAllRecordCountRelation() {
        return allRecordCountRelation;
    }

  /** Constructor for use by subclasses. */
  protected Equivalence() {}

  /**
   * Returns {@code true} if the given objects are considered equivalent.
   *
   * <p>This method describes an <i>equivalence relation</i> on object references, meaning that for
   * all references {@code x}, {@code y}, and {@code z} (any of which may be null):
   *
   * <ul>
   *   <li>{@code equivalent(x, x)} is true (<i>reflexive</i> property)

    @Override
    public String toStringWithRelation() { // #pending
        return toString();
    }

    @Override
    public String buildDisplayString(String name, boolean column, boolean relation) { // #pending
        return toString();
    }

    // ===================================================================================

   *
   * <p>Being reflexive, antisymmetric and transitive, the {@code encloses} relation defines a
   * <i>partial order</i> over ranges. There exists a unique {@linkplain Range#all maximal} range
   * according to this relation, and also numerous {@linkplain #isEmpty minimal} ranges. Enclosure
   * also implies {@linkplain #isConnected connectedness}.
   */