Defines the relationship as one-to-many mapping the parent
id to the supplied column.

@param string $columnName

@return void
557782
public function withParentIdAs(string $columnName)
    {
        call_user_func($this->callback, function ($idString, Table $parentTable) use ($columnName) {
            /** @var IEntityMapper $mapper */
            $mapper = call_user_func($this->mapperLoader);
            $mapper->addForeignKey(ForeignKey::createWithNamingConvention(
                $mapper->getPrimaryTableName(),
                [$columnName],
                $parentTable->getName(),
                [$parentTable->getPrimaryKeyColumnName()],
                $this->identifying
                    ? ForeignKeyMode::CASCADE
                    : ForeignKeyMode::SET_NULL,
                ForeignKeyMode::CASCADE
            ));

            if ($this->orderPersistColumn) {
                $persistHook = new OrderIndexPropertyLoaderHook(
                    $mapper->getObjectType(),
                    $mapper->getPrimaryTable(),
                    $this->orderPersistColumn,
                    $columnName,
                    $mapper->getDefinition()->getPropertyLinkedToColumn($this->orderPersistColumn)
                );

                $mapper->addPersistHook($persistHook);
                $persistHookId = $persistHook->getIdString();
            } else {
                $persistHookId = null;
            }

            return new ToManyRelation(
                $idString,
                $this->loadIds
                    ? new ToManyRelationIdentityReference($mapper, $this->bidirectionalRelationProperty)
                    : new ToManyRelationObjectReference($mapper, $this->bidirectionalRelationProperty, $persistHookId),
                $columnName,
                $this->identifying
                    ? new IdentifyingRelationMode()
                    : new NonIdentifyingRelationMode(),
                $this->orderByColumnNameDirectionMap,
                $this->orderPersistColumn
            );
        });
    }
649080
public void showColumn(Object columnName) {
		for (TableColumn column : allColumns) {
			if (column.getHeaderValue().equals(columnName)) {
				showColumn(column);
				break;
			}
		}
	}
56065
protected function _setColumnNumber($columnNumber)
    {
        if ($columnNumber !== null) {
            try {
                $columnNumber = $this->_normalizeInt($columnNumber);
            } catch (RootException $e) {
                throw $this->_createInvalidArgumentException($this->__('Invalid column number'), null, $e, $columnNumber);
            }

            if ($columnNumber < 1) {
                throw $this->_createInvalidArgumentException($this->__('Column number must be positive'), null, null, $columnNumber);
            }
        }

        $this->columnNumber = $columnNumber;
    }
40393
public function addRelation($columnName)
    {
        $relationName = getRelationName($columnName);

        if (
            ! array_key_exists($relationName, $this->relations) &&
            ! in_array($relationName, $this->relations)
        ) {
            $methodName = camel_case('laratables_'.$relationName.'relation_query');
            if (method_exists($this->class, $methodName)) {
                $this->relations[$relationName] = $this->class::$methodName();

                return;
            }

            $this->relations[] = $relationName;
        }
    }
235635
public function column(string $columnName): ColumnTypeDefiner
    {
        return new ColumnTypeDefiner(
            $this,
            function (Column $column) {
                $this->addColumn($column);
            },
            $columnName
        );
    }
1346510
protected function mapColumName($columnName)
    {

        // query whether or not we can match the column name
        if (isset($this->defaultAddressMapping[$columnName])) {
            return $this->defaultAddressMapping[$columnName];
        }

        // throw an exception if NOT
        throw new \Exception(sprintf('Can\'t map member name to default address column "%s"', $columnName));
    }
926985
public function getAttributeNameForColumn($columnName)
    {
        if (!empty($this->mappings)) {
            if (isset($this->mappings[$columnName])) {
                return $this->mappings[$columnName];
            }
        }

        return $columnName;
    }
1225989
public function removeValidatorForColumn($columnName)
    {
        foreach ($this->validatorList as $key => $validator) {
            if ($validator->getColumnName() == $columnName) {
                unset($this->validatorList[$key]);
            }
        }
    }
200571
public function define_columns($columns) {
        parent::define_columns($columns);
        foreach ($this->columns as $column => $column) {
            // Automatically assign classes to columns.
            $this->column_class[$column] = ' ' . $column;
        }
    }
593207
protected function addRelationChild($tableName) {
		$parameter = new ParameterGenerator();
		$parameter->setName('whereArray');
		$parameter->setDefaultValue([]);
		
		$child = new NameManager($this->getNames()->namespace, $tableName);
		
		// METHOD:getRelationChild
		$functionName = ucwords($tableName); 
		$method = $this->buildMethod("gather{$functionName}");
		$method->setParameter($parameter);
		$body = <<<MBODY
if (!is_array(\$whereArray)) {
	\$whereArray = [];
}
\$where = array_merge(['fk_{$this->getNames()->tableName}' => \$this->{$this->getNames()->primary}], \$whereArray);
\${$child->tableName} = new \\{$child->namespace_model}\\{$child->modelName}();
return \${$child->tableName}->select(\$where);
MBODY;
		$method->setBody($body);
		$tag = new ReturnTag();
		$tag->setTypes("\\Zend\\Db\\ResultSet\\HydratingResultSet");
		$docBlock = new DocBlockGenerator();
		$docBlock->setTag(new ParamTag('whereArray', ['datatype'  => []]));
		$docBlock->setTag($tag);
		$docBlock->setShortDescription("Related {$child->entityName}");
		$method->setDocBlock($docBlock);
		$this->_class->addMethodFromGenerator($method);
	}
330981
public function getFieldForColumn($columnName)
    {
        if (isset($this->fieldNames[$columnName])) {
            return $this->fieldNames[$columnName];
        } else {
            foreach ($this->associationMappings as $assocName => $mapping) {
                if ($this->isAssociationWithSingleJoinColumn($assocName) &&
                    $this->associationMappings[$assocName]['joinColumns'][0]['name'] == $columnName) {

                    return $assocName;
                }
            }

            throw MappingException::noFieldNameFoundForColumn($this->name, $columnName);
        }
    }
347116
public function increments($columnName)
    {
        $column = $this->integer($columnName, true, true);
        $this->primary($columnName);

        return $column;
    }
1141204
public function addColumn(TableColumn $column): void
  {
    // Add the column to our array of columns.
    $this->columns[$this->columnIndex] = $column;

    $column->onAddColumn($this, $this->columnIndex);

    // Increase the index for the next added column.
    $this->columnIndex += $column->getColSpan();
  }
721707
public function setForeignKey($tableName, $columnName)
    {
        if ($tableName && $columnName) {
            $this->relatedTableName = $tableName;
            $this->relatedColumnName = $columnName;
        } else {
            $this->relatedTableName = "";
            $this->relatedColumnName = "";
        }
    }
383780
public function columns($columnName, $label = null)
    {
        if (!is_string($columnName)) {
            throw new \InvalidArgumentException('$columnName must be set');
        }

        if ($this->resetColumns) {
            $this->columns = [];
            $this->resetColumns = false;
        }
        if (is_null($label)) {
            $label = $columnName;
        }
        $this->columns[$columnName] = $label;
        return $this;
    }
1035968
public function withParentIdAs(string $column) : ManyToManyRelatedIdDefiner
    {
        return new ManyToManyRelatedIdDefiner(
                $this->callback,
                $this->mapperLoader,
                $this->joinTableName,
                $column,
                $this->bidirectionalRelationProperty,
                $this->loadIds
        );
    }
760539
public static function belongsTo($model, $parentColumn) {
        $r = new static(['type' => DbRelations::BELONGS_TO, 'model' => $model]);
        return $r->columnsEqual($parentColumn, $model::getDb()->getTablePk($model::getTableName()));
    }