Is this column inheritied from another relation
@param Column The original inherited column.
@return bool
975832
public function isInherited( &$originalColumn = null )
    {

        $inhcount = $this->attinhcount;
        if( $inhcount == 0 ) {
            $originalColumn = null;
            return false;
        }

        // short cut to prevent the work of finding the original column
        if( func_num_args() === 0 ) {
            return true;
        }

        // keep knocking off the parents until we reach the root
        $originalRelation = $this->getRelation();

        do {
            $originalRelation = $originalRelation->getParent();
        } while( --$inhcount > 0 );

        $originalColumn = $originalRelation->getAttributeByName( $this->name );
        return true;

    }
452226
protected function isColumnTranslated(Model $model, $column)
    {
        $info = $this->getModelInformation($model);

        if ($info) {
            return (    $info->translated
                    &&  array_key_exists($column, $info->attributes)
                    &&  $info->attributes[$column]->translated
                    );
        }

        // Determine based on model itself
        if ( ! $this->hasTranslatableTrait($model)) return false;

        /** @var Translatable $model */
        return $model->isTranslationAttribute($column);
    }
937081
protected function validTypes(Column $column)
    {

        if (in_array($column->getType(), $this->columns) === false) {
            throw new ExceptionFactory('Column', ['COLUMN_DOES_NOT_SUPPORT', $column->getType(), $column->getName()]);
        }

        return true;
    }
13850
public function modifyTable()
    {
        $table = $this->getTable();
        if (!$table->hasPrimaryKey() && !$table->hasBehavior('concrete_inheritance')) {
            $columnAttributes = array_merge(['primaryKey' => 'true'], $this->getParameters());
            $this->getTable()->addColumn($columnAttributes);
        }
    }
370637
public function inherits($class)
    {
        if ($this instanceof $class) {
            return true;
        }

        $objects = array_values($this->__mixed_methods);

        foreach($objects as $object)
        {
            if($object instanceof $class) {
                return true;
            }
        }

        return false;
    }
1258657
protected function setColumnPropertiesFor($column)
    {
        $columnName = $column['name'];

        if ($column['searchable'] == 'true' && ! in_array($columnName, config('laratables.non_searchable_columns'))) {
            $this->searchColumns[] = $columnName;
        }

        if ($this->isCustomColumn($columnName) && ! isRelationColumn($columnName)) {
            return;
        }

        if (isRelationColumn($columnName)) {
            $this->relationshipsManager->addRelation($columnName);

            if ($foreignKeys = $this->relationshipsManager->getRelationSelectColumns($columnName)) {
                array_push($this->selectColumns, ...$foreignKeys);
            }

            return;
        }

        $this->selectColumns[] = $columnName;
    }
682299
public function withRelatedIdAs(string $column)
    {
        call_user_func($this->callback, function ($idString, Table $parentTable) use ($column) {
            $mapper = call_user_func($this->mapperLoader);

            return new ManyToManyRelation(
                    $idString,
                    $this->loadIds
                            ? new ToManyRelationIdentityReference($mapper, $this->bidirectionalRelationProperty)
                            : new ToManyRelationObjectReference($mapper, $this->bidirectionalRelationProperty),
                    $this->joinTableName,
                    $parentTable->getName(),
                    $parentTable->getPrimaryKeyColumn(),
                    $this->parentIdColumn,
                    $column
            );
        });
    }
568491
function is_sortable($column = null) {
        if (empty($column)) {
            return $this->is_sortable;
        }
        if (!$this->is_sortable) {
            return false;
        }
        return !in_array($column, $this->column_nosort);
    }
1070
@Pure
	public boolean isColumnSelectable(DBaseFileField column) {
		return column != null && (this.selectedColumns.isEmpty()
				|| this.selectedColumns.contains(column));
	}
604485
public function isLocalColumnsRequired()
    {
        foreach ($this->getLocalColumns() as $columnName) {
            if (!$this->getTable()->getColumn($columnName)->isNotNull()) {
                return false;
            }
        }

        return true;
    }
1206532
protected function inheritFromParent(BaseQuery $parent)
    {
        parent::inheritFromParent($parent);

        if (isset($parent->database)) {
            $this->database = $parent->database;
        }
        if (isset($parent->table)) {
            $this->table = $parent->table;
        }
    }
75114
protected function isColumnOnModelTable(Model $model, $column)
    {
        $info = $this->getModelInformation($model);

        if ($info) {
            return (    array_key_exists($column, $info->attributes)
                    &&  ! $info->attributes[$column]->translated
                    );
        }

        // Determine based on model itself
        return ($model->getKeyName() == $column || $model->isFillable($column) || $model->isGuarded($column));
    }
244850
function(cell) {

        var cellId = (joint.util.isString(cell) || joint.util.isNumber(cell)) ? cell : cell.id;
        var ancestor = this.getRelationshipAncestor();

        return !!ancestor && (ancestor.id === cellId || ancestor.isEmbeddedIn(cellId));
    }
287989
private boolean isDescendant(DependencyInfo ancestor, DependencyInfo descendant){
        for (DependencyInfo child : ancestor.getChildren()){
            if (child.equals(descendant)){
                return true;
            }
            if (isDescendant(child, descendant)){
                return true;
            }
        }
        return false;
    }
731177
public static boolean hasColumn(Schema schema, String columnName)
    {
        try
        {
            schema.getColumn(columnName);
            return true;
        }
        catch (IllegalArgumentException e)
        {
            return false;
        }
    }
916940
public static function hasColumn(\Illuminate\Database\Eloquent\Model $model, string $column): bool
    {
        $table = $model->getTable();
        $columns = app('cache')->remember('amigrid.columns.' . $table, 60, function () use ($table) {
            return \Schema::getColumnListing($table);
        });
        return array_search($column, $columns) !== false;
    }
679334
boolean isUniqueWithColumns(int[] cols) {

        if (constType != UNIQUE || core.mainCols.length != cols.length) {
            return false;
        }

        return ArrayUtil.haveEqualSets(core.mainCols, cols, cols.length);
    }