Make the description of a column.

        Make the description object of the given column as
        :func:`makecoldesc` is doing with the description given by
        :func:`getcoldesc`.
437951
def coldesc(self, columnname, actual=True):
        
        import casacore.tables.tableutil as pt
        return pt.makecoldesc(columnname, self.getcoldesc(columnname, actual))
1228462
def go_to_column(self, column):
        

        cursor = self.textCursor()
        cursor.setPosition(cursor.block().position() + column)
        self.setTextCursor(cursor)
        return True
1251562
def describe(cls) -> None:
        
        max_lengths = []
        for attr_name in cls.attr_names():
            attr_func = "%ss" % attr_name
            attr_list = list(map(str, getattr(cls, attr_func)())) + [attr_name]
            max_lengths.append(max(list(map(len, attr_list))))
        row_format = "{:>%d} | {:>%d} | {:>%d}" % tuple(max_lengths)
        headers = [attr_name.capitalize() for attr_name in cls.attr_names()]
        header_line = row_format.format(*headers)
        output = "Class: %s\n" % cls.__name__
        output += header_line + "\n"
        output += "-"*(len(header_line)) + "\n"
        for item in cls:
            format_list = [str(getattr(item, attr_name))
                           for attr_name in cls.attr_names()]
            output += row_format.format(*format_list) + "\n"
        print(output)
202309
def described_as(self, description, *args):
        
        if len(args):
            description = description.format(*args)
        self.description = description
        return self
484386
function Description(def) {
  if(typeof def === 'string') {
    this.parse(def);
  }else if(def
    && typeof def === 'object'
    && typeof def.txt === 'string'
    && typeof def.md === 'string') {
    this.md = def.md;
    this.txt = def.txt;
  }else{
    throw new Error('invalid value for description');
  }
}
245955
def describe_table(self, table_name):
        
        data = {'TableName' : table_name}
        json_input = json.dumps(data)
        return self.make_request('DescribeTable', json_input)
1319532
def ColumnItem(name='', key=None, **kwargs):
    ''
    return Column(name,
            expr=key if key is not None else name,
            getter=lambda col,row: getitemdef(row, col.expr),
            setter=lambda col,row,val: setitem(row, col.expr, val),
            **kwargs)
433686
def create_column(self, name, type):
        
        name = normalize_column_name(name)
        if self.has_column(name):
            log.debug("Column exists: %s" % name)
            return
        self._sync_table((Column(name, type),))
663606
function describe( object ) {
  return Object.getOwnPropertyNames( object )
    .reduce( function( desc, key ) {
      desc[ key ] = Object.getOwnPropertyDescriptor( object, key )
      return desc
    }, Object.create( null ))
}
1287933
private ColumnDefinition[] columnDefinitions(ColumnDefinition[] columns, String[] order)
   {
      Map<String, ColumnDefinition> map = makeColumnMap(columns);
      ColumnDefinition[] result = new ColumnDefinition[order.length];
      for (int index = 0; index < order.length; index++)
      {
         result[index] = map.get(order[index]);
      }
      return result;
   }
622749
function getColumnType(columnDefinitions, columnName) {
    Validate.isObject(columnDefinitions);
    Validate.notNull(columnDefinitions);
    Validate.isString(columnName);
    Validate.notNullOrEmpty(columnName);

    for (var column in columnDefinitions) {
        if (column.toLowerCase() === columnName.toLowerCase()) {
            return columnDefinitions[column];
        }
    }
}
268800
def short_description(description):
    
    def decorator(func):
        if isinstance(func, property):
            func = func.fget
        func.short_description = description
        return func
    return decorator
1107097
@Override
    public void describe(Table table, Schema schema) {
        table.addPartitionKey(getColumnName(), getDataType());
    }
64097
def from_description(cls, table):
        
        throughput = table.provisioned_throughput
        attrs = {}
        for data in getattr(table, "attribute_definitions", []):
            field = TableField(data["AttributeName"], TYPES_REV[data["AttributeType"]])
            attrs[field.name] = field
        for data in getattr(table, "key_schema", []):
            name = data["AttributeName"]
            attrs[name].key_type = data["KeyType"]
        for index in getattr(table, "local_secondary_indexes", []):
            for data in index["KeySchema"]:
                if data["KeyType"] == "RANGE":
                    name = data["AttributeName"]
                    index_type = index["Projection"]["ProjectionType"]
                    includes = index["Projection"].get("NonKeyAttributes")
                    attrs[name] = attrs[name].to_index(
                        index_type, index["IndexName"], includes
                    )
                    break
        global_indexes = {}
        for index in getattr(table, "global_secondary_indexes", []):
            idx = GlobalIndex.from_description(index, attrs)
            global_indexes[idx.name] = idx
        return cls(
            table,
            attrs,
            global_indexes,
            throughput["ReadCapacityUnits"],
            throughput["WriteCapacityUnits"],
            throughput["NumberOfDecreasesToday"],
            table.table_size_bytes,
        )
623852
def _make_op(self, column, op, value):
        
        if not op:
            return None
        if op == '>':
            return column>value
        elif op == '<':
            return column<value
        elif op == '>=':
            return column>=value
        elif op == '<=':
            return column<=value
        elif op == '==':
            return column==value
        elif op == '!=':
            return column!=value
        elif op == 'in':
            return column.in_(value)
        else:
            raise KeyError('Not support this op[%s] value' % op)
573785
function createColumn (model, column) {
    // build query
    var sql = `ALTER TABLE ${quoteName(model.name)} ADD COLUMN ${createTableColumn(model, column.name, column.spec)}`
    // add column first
    if (column.spec.first) {
        sql += ' FIRST'
    }
    // add column after
    if (column.spec.after) {
        sql += ` AFTER ${quoteName(column.spec.after)}`
    }
    // column has unique index
    if (column.spec.unique) {
        sql += `, ADD ${createTableUniqueKey(column.name, column.spec)}`
    }
    // column has non-unique index
    else if (column.spec.index) {
        sql += `, ADD ${createTableKey(column.name, column.spec)}`
    }
    // reture sql string
    return sql
}
36519
def describe(self, **kwargs):
        
        # Use pandas to calculate the correct columns
        new_columns = (
            pandas.DataFrame(columns=self.columns)
            .astype(self.dtypes)
            .describe(**kwargs)
            .columns
        )

        def describe_builder(df, internal_indices=[], **kwargs):
            return df.iloc[:, internal_indices].describe(**kwargs)

        # Apply describe and update indices, columns, and dtypes
        func = self._prepare_method(describe_builder, **kwargs)
        new_data = self._full_axis_reduce_along_select_indices(func, 0, new_columns)
        new_index = self.compute_index(0, new_data, False)
        return self.__constructor__(new_data, new_index, new_columns)