Get the blueprint's columns definitions.

        :param blueprint: The blueprint
        :type blueprint: Blueprint

        :rtype: list
975379
def _get_columns(self, blueprint):
        
        columns = []

        for column in blueprint.get_added_columns():
            sql = self.wrap(column) + ' ' + self._get_type(column)

            columns.append(self._add_modifiers(sql, blueprint, column))

        return columns
461012
def get_columns(self, *, top=None, skip=None):
        
        url = self.build_url(self._endpoints.get('get_columns'))

        params = {}
        if top is not None:
            params['$top'] = top
        if skip is not None:
            params['$skip'] = skip
        params = None if not params else params
        response = self.session.get(url, params=params)

        if not response:
            return iter(())

        data = response.json()

        return (self.column_constructor(parent=self, **{self._cloud_data_key: column})
                for column in data.get('value', []))
368309
public function blueprint(Blueprint $blueprint) {
        foreach($blueprint->getActions() as $action) {
            $this->action($action);
        }
    }
1293312
def schema_columns(self):
        """"""
        t = self.schema_term

        columns = []


        if t:
            for i, c in enumerate(t.children):

                if c.term_is("Table.Column"):
                    p = c.all_props
                    p['pos'] = i
                    p['name'] = c.value
                    p['header'] = self._name_for_col_term(c, i)
                    

                    columns.append(p)

        return columns
911095
private function commentColumns(OracleBlueprint $blueprint)
    {
        foreach ($blueprint->commentColumns as $column => $comment) {
            $this->commentColumn($blueprint->getTable(), $column, $comment);
        }
    }
138912
def get_table_columns(self):
        """"""
        query = 'SELECT * FROM "{schema}"."{table}" limit 0'.format(table=self.table_name, schema=self.schema)
        return get_columns(self.cc, query)
316237
def get(self, columns=None):
        
        if columns is None:
            columns = ["*"]

        if self._query.get_query().columns:
            columns = []

        select = self._get_select_columns(columns)

        models = self._query.add_select(*select).get_models()

        self._hydrate_pivot_relation(models)

        if len(models) > 0:
            models = self._query.eager_load_relations(models)

        return self._related.new_collection(models)
655074
protected function getTable(array $blueprints) {
        $results = [];

        foreach($blueprints as $key => $blueprint) {
            $results[] = $this->getGeneralInformation($key, $blueprint);
        }

        return array_filter($results);
    }
416157
def blueprint(self, blueprint, **options):
        '''
        '''
        if blueprint.name in self.blueprints:
            assert self.blueprints[blueprint.name] is blueprint, \
                'A blueprint with the name "%s" is already registered.  ' \
                'Blueprint names must be unique.' % \
                (blueprint.name,)
        else:
            self.blueprints[blueprint.name] = blueprint
            self._blueprint_order.append(blueprint)
        blueprint.register(self, options)
7689
def column_to_bq_schema(self):
        
        kwargs = {}
        if len(self.fields) > 0:
            fields = [field.column_to_bq_schema() for field in self.fields]
            kwargs = {"fields": fields}

        return google.cloud.bigquery.SchemaField(self.name, self.dtype,
                                                 self.mode, **kwargs)
10477
protected function compileGeometry(Blueprint $blueprint, Fluent $command)
    {

        $dimensions = $command->dimensions ?: 2;
        $typmod = $command->typmod ? 'true' : 'false';
        $srid = $command->srid ?: 4326;

        return sprintf(
            "SELECT AddGeometryColumn('%s', '%s', %d, '%s', %d, %s)",
            $blueprint->getTable(),
            $command->column,
            $srid,
            strtoupper($command->type),
            $dimensions,
            $typmod
        );
    }
412361
def get_properties(self):
        

        names = inspect.getmembers(self, predicate=lambda x: not inspect.ismethod(x))
        return [x[0] for x in names if not x[0].startswith("_") and x[0] not in self._ignored_properties]
120797
protected function resolveForeignTable($table, Blueprint $blueprint)
    {
        $referenced = explode('.', $table);

        if (count($referenced) == 2) {
            return [
                'database' => current($referenced),
                'table' => next($referenced),
            ];
        }

        return [
            'database' => $blueprint->schema(),
            'table' => current($referenced),
        ];
    }
582800
def columns(self):
        """"""
        result = self.query.result()
        return [field.name for field in result.schema]
551598
def _by_columns(self, columns):
        
        return columns if self.isstr(columns) else self._backtick_columns(columns)
426826
def GetAllPackages(classification):
		
		packages = []
		for visibility in Blueprint.visibility_stoi.keys():
			try:
				for r in Blueprint.GetPackages(classification,visibility):  packages.append(dict(r.items()+{'Visibility':visibility}.items()))
			except:
				pass
		if len(packages):  return(packages)
478775
def compile_create(self, blueprint, command, connection):
        
        columns = ", ".join(self._get_columns(blueprint))

        sql = "CREATE TABLE %s (%s)" % (self.wrap_table(blueprint), columns)

        sql = self._compile_create_encoding(sql, connection, blueprint)

        if blueprint.engine:
            sql += " ENGINE = %s" % blueprint.engine

        return sql