Return schema process

@return Process
422874
public function getProcess(): Process
    {
        if ($this->process === null) {
            $this->process = new Process(
                $this->getSchemaName(),
                $this->getInitialState(),
                $this->buildStates()
            );
        }

        return $this->process;
    }
480261
public function getSchemaData()
    {
        $defaults = $this->getSchemaDataDefaults();
        return array_replace_recursive($defaults, array_intersect_key($this->schemaData, $defaults));
    }
277669
protected static function getSchema()
    {
        static $cache = null;
        if (!isset($cache)) {
            $schemaFile = __DIR__.'/doctrine-xml-0.5.xsd';
            $s = (is_file($schemaFile) && is_readable($schemaFile)) ? @file_get_contents($schemaFile) : false;
            if ($s === false) {
                throw new Exception('Failed to load the schema file '.$schemaFile);
            }
            $cache = $s;
        }

        return $cache;
    }
1347439
public function generate_schema() {
		$schema = "CREATE TABLE `".$this->name."` (\n";
		
		for($i = 0; $i < count($this->details); $i++) {
			
			if(!isset($this->details[$i]['options'])) {
				$this->details[$i]['options'] = array();
			}
			
			$schema .= "`".$this->details[$i]['name']."` ";
			$schema .= $this->type($this->details[$i]);
			$schema .= $this->options($this->details[$i]['options']);
			$schema .= ",\n";
		}
		
		$schema .= $this->table_keys();
		$schema .= ')';
		$schema .= $this->engine();
		
		return $schema;
	}
530373
public function getSchemaFactory()
    {
        if (!$this->schemaFactory) {
            $this->schemaFactory = new LdapObjectSchemaFactory(
                $this->getCache(), $this->getSchemaParser(), $this->config->getEventDispatcher()
            );
        }

        return $this->schemaFactory;
    }
550789
public function getConfig(Schema $schema = null)
    {
        if (!$schema) {
            $schema = new Schema();
        }

        $config = new Config();

        foreach ($this->resources as $resource) {
            $values = $this->loadResource($resource[0], $resource[2]);
            if (is_string($prefix = $resource[1])) {
                $values = [
                    $prefix => $values,
                ];
            }

            $config->merge($values);
        }

        foreach ($this->processors as $processor) {
            $processor->onPostMerge($config, $schema);
        }

        return $config;
    }
167169
public function getDefaultSchema(): ?Builder
    {
        // By default, the schema facade depends upon a
        // database connection being available. Therefore,
        // we need to ensure that this is true, before
        // attempting to return the facade-root
        $manager = DB::getFacadeRoot();
        if (isset($manager) && ! is_null($manager->connection())) {
            return Schema::getFacadeRoot();
        }
        return $manager;
    }
828734
protected function createSchema()
    {
        $schema = new ModelSchema("tblInvite");
        $schema->addColumn(
            new UUID("InviteID"),
            new String("Email", 150),
            new ForeignKey("UserID"),
            new String("AccountID", 50),
            new Boolean("Accepted", false),
            new Boolean("Sent", false),
            new DateTime("SentDate")
        );

        $schema->uniqueIdentifierColumnName = 'InviteID';

        return $schema;
    }
486599
protected function createSchema()
    {
        $schema = new ModelSchema("tblAuthenticationUser");

        $schema->addColumn(
            new AutoIncrementColumn("UserID"),
            new StringColumn("Username", 30, null),
            new StringColumn("Password", 200),
            new StringColumn("Forename", 80),
            new StringColumn("Surname", 80),
            new StringColumn("Email", 150),
            new StringColumn("Token", 200),
            new DateTimeColumn("TokenExpiry"),
            new BooleanColumn("Enabled", false),
            new StringColumn("PasswordResetHash", 200),
            new DateTimeColumn("PasswordResetDate"),
            new DateTimeColumn("LastPasswordChangeDate")
        );

        $schema->labelColumnName = "FullName";

        return $schema;
    }
625830
public function getCurrentSchema()
    {
        try {
            $schema = $this->zendAdapter->getDriver()->getConnection()->getCurrentSchema();
        } catch (\Exception $e) {
            throw new Exception\RuntimeException('Cannot retrieve current schema:' . $e->getMessage());
        }

        return $schema;
    }
904850
public function getCurrentSchema()
    {
        try {
            $schema = $this->dbal->getDatabase();
        } catch (\Exception $e) {
            throw new Exception\RuntimeException('Cannot retrieve current schema:' . $e->getMessage());
        }

        return $schema;
    }
856493
public static function get_schema($name = 'default')
    {
        $connection = self::get_conn($name);
        if ($connection) {
            return $connection->getSchemaManager();
        }
        return null;
    }
115487
public function getSchema()
    {
        $result = null;

        if ($this->isConnected()){
            $result = $this->getDriver()->getTableSchema($this->getBase());
        }

        return $result;
    }
968645
public function getScheme()
    {
        if ($this->_schema === null) {
            $this->_schema = $this->isSecureConnection() ? 'https' : 'http';
        }

        return $this->_schema;
    }
208455
public function getSchema()
    {
        if ($this->_schema === null) {
            $this->_schema = $this->_initializeSchema(
                $this->getConnection()
                    ->getSchemaCollection()
                    ->describe($this->getTable())
            );
        }

        return $this->_schema;
    }
25067
protected function getSchemaForEntity(): Schema
    {
        if ($this->entityClass instanceof Schema) {
            return $this->entityClass;
        }

        $model = new $this->entityClass();

        if ($model instanceof ActiveRecord) {
            return $model->getSchema();
        }

        return new DynamicSchema();
    }
233924
public function exec()
    {
        $schema = $this->argument('schema');

        $process = Migrations::exec($schema);
        //
        $this->show($process);
        $this->backup($process);
    }