The property name used in the ModelConnector for the given column, virtual column or table

@param ColumnInterface $objColumn

@return string
@throws \Exception
346552
public static function modelConnectorPropertyName(ColumnInterface $objColumn)
    {
        if ($objColumn instanceof SqlColumn) {
            if ($objColumn->Reference) {
                return $objColumn->Reference->PropertyName;
            } else {
                return $objColumn->PropertyName;
            }
        } elseif ($objColumn instanceof ReverseReference) {
            if ($objColumn->Unique) {
                return ($objColumn->ObjectDescription);
            } else {
                return ($objColumn->ObjectDescriptionPlural);
            }
        } elseif ($objColumn instanceof ManyToManyReference) {
            return $objColumn->ObjectDescriptionPlural;
        } else {
            throw new \Exception ('Unknown column type.');
        }
    }
1149060
public function getColumn($sColumn, $sDefault = null)
    {
        $sColumn = ucfirst(trim($sColumn));
        if (property_exists($this, 'table' . $sColumn . 'Column')) {
            return $this->{'table' . $sColumn . 'Column'};
        }
        return $sDefault;
    }
566733
final D6ModelClassFieldInfo getFieldInfo(String columnName) {
		final D6ModelClassFieldInfo fieldInfo = mColumnNameFieldInfoMap
				.get(columnName);
		return fieldInfo;
	}
727214
public function getFieldName($columnName)
    {
        return isset($this->fieldNames[$columnName]) ?
                $this->fieldNames[$columnName] : $columnName;
    }
1101104
public function modelConnectorLabelVariableName(ColumnInterface $objColumn)
    {
        $strPropName = static::modelConnectorPropertyName($objColumn);
        return \QCubed\Codegen\Generator\Label::instance()->varName($strPropName);
    }
5942
@Override
	public String onColumnName(String columnName) {
		if (onlyBindParameter)
			return null;

		if (currentSchema != null) {
			Set<SQLProperty> props = currentSchema.getPropertyBySimpleName(columnName);
			AssertKripton.assertTrueOrUnknownPropertyInJQLException(props != null && props.size() > 0, currentMethod, columnName);
			return props.iterator().next().columnName;
		} else {
			return null;
		}
	}
959967
public static function getFields($object)
    {
        $objectClass = BeanFactory::getObjectClass($object);
        if(!isset(static::$fields[$objectClass]))
        {
            $annotationsSet = AnnotationManager::getPropertiesAnnotations($objectClass, Column::class);
            $fields = [];
            foreach($annotationsSet as $propertyName => $annotations)
            {
                $annotation = $annotations[0];
                $fields[$annotation->name ?? $propertyName] = $annotation;
            }
            static::$fields[$objectClass] = $fields;
        }
        return static::$fields[$objectClass];
    }
964773
public function getConnectionTableName()
    {
        $type_names = [$this->getSourceTypeName(), $this->getTargetTypeName()];
        sort($type_names);

        return implode('_', $type_names);
    }
936816
public String getColumnClassName(int column) throws SQLException
    {
        sourceResultSet.checkColumnBounds(column);
        VoltType type = sourceResultSet.table.getColumnType(column - 1);
        String result = type.getJdbcClass();
        if (result == null) {
            throw SQLError.get(SQLError.TRANSLATION_NOT_FOUND, type);
        }
        return result;
    }
1076058
public function getColumnMetadata(string $columnName): ColumnMetadata
    {
        if (!array_key_exists($columnName, $this->columnMetadataList)) {
            throw new \RuntimeException('Table "' . $this->tableName . '" doesn\'t contain column "' . $columnName . '"');
        }

        return $this->columnMetadataList[$columnName];
    }
840284
public function generateFormColumn(array $_columns_to_be_displayed, BeanInterface $bean)
    {
        $_form_fields = "";

        foreach ($_columns_to_be_displayed as $_column) {
            if ($_column instanceof ColumnInterface) {
                $_field_html = "";

                $_show_label = $this->getConfigForElement(Config::read('form'), 'showLabels', $bean->getName(), 'beans');

                if ($_show_label) {
                    $_field_html = $this->generateElement('label', array(
                        'for' => "PyntaxDAO[{$bean->getName()}][{$_column->getName()}]"
                    ), $this->convertColumnNameIntoLabel($_column->getName()), true);

                    $_label_container = Config::read(array('form','label_container'));
                    if (isset($_label_container) && isset($_label_container['tagName'])) {
                        $_label_element_container = $this->generateElement($_label_container['tagName'],
                            isset($_label_container['attributes']) && is_array($_label_container['attributes']) ?$_label_container['attributes'] : array(),
                            $_field_html
                        );

                        $_field_html = $_label_element_container;
                    }
                }

                $_element_container = Config::read(array('form','element_container'));
                if (isset($_element_container) && isset($_element_container['tagName'])) {

                    $_element_html = $this->generateElementByColumn($bean, $_column);

                    $_form_element_container = $this->generateElement($_element_container['tagName'],
                        isset($_element_container['attributes']) && is_array($_element_container['attributes']) ? $_element_container['attributes'] : array(),
                        $_element_html
                    );

                    $_field_html .= $_form_element_container;
                } else {
                    $_field_html .= $this->generateElementByColumn($bean, $_column);
                }


                $_form_element_container_config = Config::read(array('form','form_element_container_template'));

                if (isset($_form_element_container_config['templateName']) && isset($_form_element_container_config['data']['tagName'])) {
                    $_field_html = $this->generateElement($_form_element_container_config['data']['tagName'],
                        is_array($_form_element_container_config['data']['attributes']) ? $_form_element_container_config['data']['attributes'] : array(),
                        $_field_html, true, $_form_element_container_config['templateName']);
                }

                $_form_fields .= $_field_html;
            }
        }

        $_primary_key_value = $bean->{$bean->getPrimaryKey()};

        if(!empty($_primary_key_value)) {
            $_form_fields.= $this->generateElement('input',array('type' => 'hidden', 'name' => "PyntaxDAO[{$bean->getName()}][{$bean->getPrimaryKey()}]"), $_primary_key_value, false);
        }

        $_form_column =  Config::read(array('form','form_column'));
        if (isset($_form_column['container_element_template']['tagName'])) {
            return $this->generateElement($_form_column['container_element_template']['tagName'],
                isset($_form_column['container_element_template']['attributes']) ? $_form_column['container_element_template']['attributes'] : array(),
                $_form_fields, true);
        }

        return $_form_fields;
    }
555987
public function generateValidator($objField, $table)
    {

        // Get Field Type
        $funcType = function () use ($objField) {

            switch ($objField->type) {
                case 'int':
                    $type = 'integer';
                    break;

                case 'char':
                case 'varchar':
                case 'text':
                case 'enum':
                    $type = 'string';
                    break;

                default:
                    $type = $objField->type;
            }

            return $type;
        };

        // Get PK name
        foreach ($table->fields as $f) {
            if ($f->pk) {
                $pk = $f->name;
            }
        }

        $validator = $funcType();
        $validator .= $objField->type === 'enum' ? '|in:' . $objField->inTypes : '';
        $validator .= $objField->size && in_array($objField->type, ['char','varchar','text'])
                        ? '|max:' . $objField->size
                        : '';
        $validator .= strpos($objField->name, 'email') !== false ? '|email' : '';
        $validator .= $objField->unique ? '|unique:' . $table->name . ',' . $pk : '';
        $validator .= $objField->required ? '|required' : '';

        return $validator;

    }
1348534
public String getColumnClassName(int column) throws SQLException {
    Field field = getField(column);
    String result = connection.getTypeInfo().getJavaClass(field.getOID());

    if (result != null) {
      return result;
    }

    int sqlType = getSQLType(column);
    switch (sqlType) {
      case Types.ARRAY:
        return ("java.sql.Array");
      default:
        String type = getPGType(column);
        if ("unknown".equals(type)) {
          return ("java.lang.String");
        }
        return ("java.lang.Object");
    }
  }
721997
public function getModelColumn()
    {
        if (empty($this->_modelColumn)) {
            if (!empty($this->through)) {
                if (empty($this->link)) {
                    $throughClass = $this->through;
                    $through = call_user_func([$throughClass, 'create']);

                    $name = '';
                    foreach ($through->getFields() as $fieldName => $params) {
                        if (isset($params['modelClass']) && $params['modelClass'] == $this->ownerClassName) {
                            $name = $fieldName;
                            break;
                        }
                    }

                    $this->_modelColumn = $name.'_id';
                } else {
                    list($fromId, $toId) = $this->link;
                    if (empty($this->link)) {
                        throw new Exception('throughLink is missing in configutaion');
                    }

                    $this->_modelColumn = $this->reversed ? $toId : $fromId;
                }
            } else {
                $cls = $this->ownerClassName;
                $end = $this->getModelPk();
                if ($cls == $this->modelClass) {
                    $end = $this->reversed ? 'to_id' : 'from_id';
                }
                $tmp = explode('\\', $cls);
                $column = AbstractModel::normalizeTableName(end($tmp));
                $this->_modelColumn = $column.'_'.$end;
            }
        }

        return $this->_modelColumn;
    }
166384
public function getColumnDefinition(ColumnInterface $column)
    {
        $sql = parent::getColumnDefinition($column);
        if ($column instanceof Column && $column->getComment()) {
            $sql .= " COMMENT \"" . addcslashes($column->getComment(), '"') . "\"";
        }
        $def = $column->getDefault();
        // empty value will ignore when create table
        if (isset($def) && in_array($def, [0, '', '0'])) {
            $sql .= ' DEFAULT "' . $def . '"';
        }
        if ($column->getType() == Column::TYPE_INTEGER
            && $column->getSize() == 4) {
            $sql = preg_replace('/^INT/', 'TINYINT', $sql);
        }
        return $sql;
    }
1099097
public function getColumn($columnIndex)
    {
        //check whether worksheet name is set or not
        if ($this->worksheetName == '')
            throw new Exception('Worksheet name not specified');
        $strURI = Product::$baseProductUri . '/cells/' . $this->getFileName() .
            '/worksheets/' . $this->worksheetName . '/cells/columns/' . $columnIndex;
        $signedURI = Utils::sign($strURI);
        $responseStream = Utils::processCommand($signedURI, 'GET', '', '');
        $json = json_decode($responseStream);
        return $json->Column;

    }
852366
static function columnNameToLabel($columnname)
    {
        $retstring = str_replace("_", " ", $columnname);
        if (!function_exists("mb_strtolower")) {
            $retstring = ucwords(strtolower($retstring));
        } else {
            $retstring = ucwords(mb_strtolower($retstring, ReporticoLocale::outputCharsetToPhpCharset(ReporticoApp::getConfig("output_encoding"))));
        }

        return $retstring;
    }