require these columns
512240
def st_require_cols dict
      dcols = dict.keys.to_set
      unless @require_cols.subset? dict.keys.to_set
        missing_cols = (@require_cols - dcols).to_a
        raise ReindeerETL::Errors::RecordInvalid.new("Missing required columns: #{missing_cols}")
      end
    end
615423
def setColumns(self, columns):
        
        self.__columns = {}
        for name, column in columns.items():
            self.__columns[name] = column
            column.setSchema(self)
233938
protected function needToSortColumns()
    {
        foreach ($this->config->getColumns() as $column) {
            if ($column->getOrder() !== 0) {
                return true;
            }
        }
        return false;
    }
414838
def method_missing(m, *args, &block)
      column_name = m.to_s.gsub(/\=$/, '')
      raise ExtendModelAt::InvalidColumn, "#{column_name} not exist" if @static == true and not (@columns.try(:keys).try(:include?, column_name.to_sym) )
      # If the method don't finish with "=" is fore read
      if m !~ /\=$/
        self[m.to_s]
      # but if finish with "=" is for wirte
      else
        self[column_name.to_s] = args.first
      end
    end
843339
def requiredUnless(col_name, arg, dm, df, *args):
    
    # if column name is present, no need to check if it is required
    if col_name in df.columns:
        return None
    arg_list = arg.split(",")
    arg_list = [argument.strip('"') for argument in arg_list]
    msg = ""
    for a in arg_list:
        # ignore validations that reference a different table
        if "." in a:
            continue
        if a not in df.columns:
            msg += "{} column is required unless {} is present.  ".format(col_name, a)
    if msg:
        return msg
    else:
        return None
    return None
603923
def SetColumns( self, columns, sortOrder=None ):
        """"""
        self.columns = columns 
        self.sortOrder = [(x.defaultOrder,x) for x in self.columns if x.sortDefault]
        self.CreateColumns()
362177
def setColumns( self, columns ):
        
        self.treeWidget().setColumns(columns)
        item = self.treeWidget().headerItem()
        for i in range(item.columnCount()):
            item.setTextAlignment(i, Qt.AlignBottom | Qt.AlignHCenter)
1289677
def from_columns_dict(cls, columns):
        """"""
        warnings.warn("Table.from_columns_dict is deprecated. Use Table().with_columns(...)", FutureWarning)
        return cls().with_columns(columns.items())
967380
def setColumns( self, columns ):
        
        self.setColumnCount(len(columns))
        self.setHorizontalHeaderLabels(columns)
426957
protected static function loadColumnListing()
    {
        if (empty(static::$columnListing)) {
            $instance = new static;

            static::$columnListing = $instance->getConnection()
                                        ->getSchemaBuilder()
                                        ->getColumnListing($instance->getTable());
        }
    }
500494
function Column (table, header, i) {
  this._table = table, this._header = header, this._i = i
}
183788
@Override
    public Table addColumns(final Column<?>... cols) {
        for (final Column<?> c : cols) {
            validateColumn(c);
            columnList.add(c);
        }
        return this;
    }
775640
def available_columns
      column_options.reject{|column| viable_report_columns.map(&:column_name).include? column.name.to_s}
    end
1159204
public function requireField()
    {
        $charset = Config::inst()->get(MySQLDatabase::class, 'charset');
        $collation = Config::inst()->get(MySQLDatabase::class, 'collation');

        $parts = array(
            'datatype'=>'varchar',
            'precision'=>$this->size,
            'character set'=> $charset,
            'collate'=> $collation,
            'arrayValue'=>$this->arrayValue
        );

        $values = array(
            'type' => 'varchar',
            'parts' => $parts
        );

        DB::require_field($this->tableName, $this->name, $values);
    }
73394
def required_fields(self):
        """"""
        return {f:v for f, v in self.normal_fields.items() if v.required}
1033175
private function enhanceColumns(): void
  {
    foreach ($this->oldColumns as $table)
    {
      foreach ($table as $column)
      {
        $table_name  = $column['table_name'];
        $column_name = $column['column_name'];

        if ($column['constant_name']=='*')
        {
          $constant_name                                                = strtoupper($column['column_name']);
          $this->oldColumns[$table_name][$column_name]['constant_name'] = $constant_name;
        }
        else
        {
          $constant_name                                                = strtoupper($this->oldColumns[$table_name][$column_name]['constant_name']);
          $this->oldColumns[$table_name][$column_name]['constant_name'] = $constant_name;
        }
      }
    }
  }
763999
public function autosetColumns()
    {
        $value = $this->value;
        if (empty($this->columns)) {
            $dataValue = $value;
            if (count($dataValue)) {
                $firstValue = (array) $dataValue[0];
                foreach (array_keys($firstValue) as $header) {
                    $this->addColumn($header);
                }
            }
        }
    }