Returns the schema for the given field

@param string $name
@return Schema
161226
public function get($name) {
		if (!$this->definitions->has($name)) {
			$this->definitions->set($name, new Schema());
		}
		return $this->definitions->get($name);
	}
1359570
function GetSchema() {
		$this->LoadSchema();
		$schema = array(
			'_model' => $this->model,
			'_table' => $this->table,
		);
		$schema = array_merge($schema, $this->schema);
		$schema['_id'] = $this->schema['_id']['field'];
		$this->Trigger('getschema', $schema);
		return $schema;
	}
53052
protected function getField($name)
    {
        $name = ltrim($name, '/');

        foreach ($this->fields as $field) {
            if (preg_match('#^' . ltrim($field->getName(), '/') . '$#', $name)) {
                return $field;
            }
        }

        return null;
    }
385196
public function getColumnMeta($name = '')
    {

        $retval = array();
        $field = NULL;
        while ($field = mysqli_fetch_field($this->getResultId())) {
            $f = new stdClass();
            $f->name = $field->name;
            $f->type = $field->type;
            $f->default = $field->def;
            $f->maxLength = $field->max_length;
            $f->primaryKey = $field->primary_key;

            $retval[] = $f;
        }

        return $retval;
    }
1127706
private function convertProperty($name)
    {
        if (isset($this->_schema[$name]['null']) && $this->_schema[$name]['null'] && $this->$name === null) {
            return;
        }

        switch ($this->_schema[$name]['type']) {
        case Object::TYPE_ID:
            if (!($this->$name instanceof MongoId) && $this->$name !== null) {
                $this->$name = new MongoId($this->$name);
            }
            break;
        case Object::TYPE_BOOL:
            if (!is_bool($this->$name)) {
                $this->$name = (bool) $this->$name;
            }
            break;
        case Object::TYPE_INT:
            if (!is_int($this->$name)) {
                $this->$name = (int) $this->$name;
            }
            break;
        case Object::TYPE_DOUBLE:
            if (!is_double($this->$name)) {
                $this->$name = (double) $this->$name;
            }
            break;
        case Object::TYPE_STRING:
            if (!is_string($this->$name)) {
                $this->$name = (string) $this->$name;
            }
            break;
        case Object::TYPE_ARRAY:
            if (!is_array($this->$name)) {
                $this->$name = [];
            }
            break;
        case Object::TYPE_DATE:
            if (!($this->$name instanceof MongoDate)) {
                $this->$name = new MongoDate($this->$name);
            }
            break;
        case Object::TYPE_REFERENCE:
            if (!MongoDBRef::isRef($this->$name)) {
                $this->$name = null;
            }
            break;
        default:
            throw new Exception("Property '{$name}' type is unknown ({$this->_schema[$name]['type']})");
        }
        return null;
    }
1053289
public function getField($name)
    {
        return $this->fields->has($name) ? $this->fields[$name] : null;
    }
1100484
public function getFieldValue($name)
    {
        $fieldValues = $this->toArray();
        return (isset($fieldValues[$name])) ? $fieldValues[$name] : null;
    }
908830
public function getField($name)
    {
        return (null !== $name && array_key_exists($name, $this->fields)) ? $this->fields[$name] : null;
    }
217072
protected function _getField($name)
    {
        return ( array_key_exists($name, $this->_data) ) ? $this->_data[$name] : false;
    }
1045910
public function getFieldByName(string $name)
    {
        $found = array_filter($this->fields, function ($field) use ($name) {
            /** @var FieldTypeInterface $field */
            return $name === $field->getBaseName();
        });

        if (! empty($found)) {
            return array_pop($found);
        }

        throw new TaxonomyFieldNotFoundException("Taxonomy field with a name of {$name} not found.");
    }
594018
public function getOptionalField(string $name) : string
    {
        if (isset($this->fields[$name])) {
            if ($this->fields[$name]) {
                return \array_shift($this->fields[$name]);
            }
        }

        return '';
    }
1000226
public function getSchema(): Schema
    {
        if ($this->schema === null) {
            $this->schema = new Schema($this);
        }

        return $this->schema;
    }
759288
public function field($name) {
        $this->_fields['' . $name . ''] = new Field($name, $this->_name);

        return $this->_fields['' . $name . ''];
    }
419354
public function getField(string $name): FieldInterface
    {
        if (!$this->hasField($name)) {
            throw new DefinitionException("Field '$name' is not defined.");
        }

        return $this->fields[$name];
    }
29070
public static function getSchema($name) {
        if (!isset(self::$schemas[$name])) {
            try {
                self::$schemas[$name] = Schema::i($name);
            } catch (Exception $e) {
                return false;
            }
        }

        return self::$schemas[$name];
    }
164718
public function getColumn(string $name): AbstractColumn
    {
        if (!$this->schema->hasColumn($name)) {
            throw new DefinitionException("Undefined column {$name} in {$this->schema->getName()}");
        }

        return clone $this->schema->column($name);
    }
107034
public function field($name)
    {
        return $this->fields()->first(function (Field $field) use ($name) {
            return $field->column() == $name;
        });
    }