Create a new column ``name`` of a specified type.
        ::

            table.create_column('created_at', db.types.datetime)

        `type` corresponds to an SQLAlchemy type as described by `dataset.db.Types`
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),))
1348312
def alter_column_type(self, relation, column_name, new_column_type):
        
        kwargs = {
            'relation': relation,
            'column_name': column_name,
            'new_column_type': new_column_type,
        }
        self.execute_macro(
            ALTER_COLUMN_TYPE_MACRO_NAME,
            kwargs=kwargs
        )
1213867
function createIndex (model, column) {
    // build query
    var sql = 'ALTER TABLE '+quoteName(model.name)
    // column has unique index
    if (column.spec.unique) {
        sql = sql+' ADD '+createTableUniqueKey(column.name, column.spec)
    }
    // column has non-unique index
    else if (column.spec.index) {
        sql = sql+' ADD '+createTableKey(column.name, column.spec)
    }
    // reture sql string
    return sql
}
379378
def create_table(name)
      if ! db.tables.include?(name.to_sym)
        db.create_table name do
          String :name, :size => 15
          Float :freq
          index :freq
        end
      end
    end
533785
public static DbColumn.Builder dbColumn(String name, DbColumnType type, boolean autoInc) {
        return new DbColumn.Builder().name(name).type(type).autoInc(autoInc);
    }
770780
def createTable(self, login, tableName, versioningIter, type):
    
    self.send_createTable(login, tableName, versioningIter, type)
    self.recv_createTable()
286152
async def create(self, model_, **data):
        
        inst = model_(**data)
        query = model_.insert(**dict(inst.__data__))

        pk = await self.execute(query)
        if inst._pk is None:
            inst._pk = pk
        return inst
329498
def new_attribute(name, type)
      attributes[name] = type
      define_attr_reader(name)
      define_attr_writer(name, type)
      name
    end
1139824
def db_create_table(self, table_name, columns):
        
        formatted_columns = ''
        for col in set(columns):
            formatted_columns += '"{}" text, '.format(col.strip('"').strip('\''))
        formatted_columns = formatted_columns.strip(', ')

        create_table_sql = 'CREATE TABLE IF NOT EXISTS {} ({});'.format(
            table_name, formatted_columns
        )
        try:
            cr = self.db_conn.cursor()
            cr.execute(create_table_sql)
        except sqlite3.Error as e:
            self.handle_error(e)
318982
function (column, value, fromDatabase) {
            var colSchema, clazz = this._static;
            if (((fromDatabase && clazz.typecastOnLoad) || (!fromDatabase && clazz.typecastOnAssignment)) && !isUndefinedOrNull(this.schema) && !isUndefinedOrNull((colSchema = this.schema[column]))) {
                var type = colSchema.type;
                if (value === "" && clazz.typecastEmptyStringToNull === true && !isUndefinedOrNull(type) && ["string", "blob", "text"].indexOf(type) === -1) {
                    value = null;
                }
                var raiseOnError = clazz.raiseOnTypecastError;
                if (raiseOnError === true && isUndefinedOrNull(value) && colSchema.allowNull === false) {
                    throw new ModelError("null is not allowed for the " + column + " column on model " + clazz.tableName);
                }
                try {
                    value = clazz.db.typecastValue(type, value);
                } catch (e) {
                    if (raiseOnError === true) {
                        throw e;
                    }
                }
            }
            return value;
        }
823853
public static ColumnInformation create(String name, ColumnType type) {
    byte[] nameBytes = name.getBytes();

    byte[] arr = new byte[23 + 2 * nameBytes.length];
    int pos = 0;

    //lenenc_str     catalog
    //lenenc_str     schema
    //lenenc_str     table
    //lenenc_str     org_table
    for (int i = 0; i < 4; i++) {
      arr[pos++] = 1;
      arr[pos++] = 0;
    }

    //lenenc_str     name
    //lenenc_str     org_name
    for (int i = 0; i < 2; i++) {
      arr[pos++] = (byte) name.length();
      System.arraycopy(nameBytes, 0, arr, pos, nameBytes.length);
      pos += nameBytes.length;
    }

    //lenenc_int     length of fixed-length fields [0c]
    arr[pos++] = 0xc;

    //2              character set
    arr[pos++] = 33; /* charset  = UTF8 */
    arr[pos++] = 0;

    int len;

    /* Sensible predefined length - since we're dealing with I_S here, most char fields are 64 char long */
    switch (type.getSqlType()) {
      case Types.VARCHAR:
      case Types.CHAR:
        len = 64 * 3; /* 3 bytes per UTF8 char */
        break;
      case Types.SMALLINT:
        len = 5;
        break;
      case Types.NULL:
        len = 0;
        break;
      default:
        len = 1;
        break;
    }

    //
    arr[pos] = (byte) len; /* 4 bytes : column length */
    pos += 4;

    arr[pos++] = (byte) ColumnType.toServer(type.getSqlType()).getType(); /* 1 byte : type */

    arr[pos++] = (byte) len; /* 2 bytes : flags */
    arr[pos++] = 0;

    arr[pos++] = 0; /* decimals */

    arr[pos++] = 0; /* 2 bytes filler */
    arr[pos] = 0;

    return new ColumnInformation(new Buffer(arr));
  }
451484
def createTable(dbconn, pd):
    """"""
    cols = ('%s %s' % (defn.name, getTypename(defn)) for defn in pd.fields)
    sql  = 'CREATE TABLE IF NOT EXISTS %s (%s)' % (pd.name, ', '.join(cols))

    dbconn.execute(sql)
    dbconn.commit()
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
}
823302
def create_index(self, columns, name=None, **kw):
        
        columns = [normalize_column_name(c) for c in ensure_tuple(columns)]
        with self.db.lock:
            if not self.exists:
                raise DatasetException("Table has not been created yet.")

            for column in columns:
                if not self.has_column(column):
                    return

            if not self.has_index(columns):
                self._threading_warn()
                name = name or index_name(self.name, columns)
                columns = [self.table.c[c] for c in columns]
                idx = Index(name, *columns, **kw)
                idx.create(self.db.executable)
642435
def column(name, definition)
      @column ||= if definition.is_a?(Symbol)
                    ColumnWithType.new(name, definition)
                  else
                    ColumnWithSql.new(name, definition)
                  end
    end
832451
public S dataColumnType(String dataColumnType) {
      attributes.attribute(DATA_COLUMN_TYPE).set(dataColumnType);
      return self();
   }
1203885
def __create_table_if_not_exists(self):
        # type: () -> None
        
        if self.create_table:
            try:
                self.dynamodb.create_table(
                    TableName=self.table_name,
                    KeySchema=[
                        {
                            'AttributeName': self.partition_key_name,
                            'KeyType': 'HASH'
                        }
                    ],
                    AttributeDefinitions=[
                        {
                            'AttributeName': self.partition_key_name,
                            'AttributeType': 'S'
                        }

                    ],
                    ProvisionedThroughput={
                        'ReadCapacityUnits': 5,
                        'WriteCapacityUnits': 5
                    }
                )
            except Exception as e:
                if e.__class__.__name__ != "ResourceInUseException":
                    raise PersistenceException(
                        "Create table if not exists request "
                        "failed: Exception of type {} "
                        "occurred: {}".format(
                            type(e).__name__, str(e)))