@param   array $columns

@return  int
179068
public function set(array $columns)
    {
        parent::set($columns);
        $compiler = $this->connection->getCompiler();
        return $this->connection->count($compiler->update($this->sql), $compiler->getParams());
    }
1078541
public function setColumns(array $columns)
    {
        // add columns
        foreach($columns['add'] as $key => $value) {
            $this->dataTables->addColumn($key, $value);
        }

        // edit columns
        foreach($columns['edit'] as $key => $value) {
            $this->dataTables->editColumn($key, $value);
        }

        // remove columns
        foreach($columns['remove'] as $value) {
            $this->dataTables->removeColumn($value);
        }
    }
327075
public function columns($columns) {
		if (is_array($columns))
			$this->columnList = $columns;
		else
			$this->columnList = func_get_args();
		return $this;
	}
977211
public function orHavingMultiple(array $columns)
    {
        $instance = $this->havingStrategyInstance();

        $instance->havingStrategy()->orHavingMultiple($columns);

        return $instance;
    }
859676
public function get($columns = ['*']) {
        if (count($columns) === 1 && isset($columns[0]) && $columns[0] === '*' && !empty($this->query->selects)) {
            return $this->query->all();
        }
        return $this->query->select($columns)->all();
    }
624043
public function into($columns)
    {
        //if columns count does not match values count, throw an error.

        $valuesCount = count($this->values);
        $colStringCount = 0;
        if (is_string($columns)) {
            try {
                $colStringCount = count(
                    explode(',', $columns)
                );
            } catch (Exception $e) {

                static::$response["status"] = "error";
                static::$response["response"] = "Unrecognized characters. Please refer to documentation on how to insert a record";
                static::$response["code"] = 4001;
               return static::terminate(static::$response);

            }
        }

        if (func_num_args() > 1 && func_num_args() == $valuesCount) {
            $this->columns = $this->columnize(func_get_args());
        } else if (is_array($columns) && count($columns) == $valuesCount) {
            $this->columns = $this->columnize($columns);
        } else if ($colStringCount == $valuesCount) {
            $this->columns = $columns;
        } else {
            static::$response["status"] = "error";
            static::$response["response"] = "Columns count does not equal the values count";
            static::$response['code'] = 4005;
           return static::terminate(static::$response);
        }


        return $this->doInsert();
    }
410198
public function getCountForPagination($columns = ['*'])
    {
        $result = $this->getBuilder()->getCountForPagination($columns);

        // Reset query builder
        $this->resetBuilder();

        return $result;
    }
746190
public function columns(array $columns)
	{
		$columnsArray = array();
		foreach($columns as $column)
		{
			$columnsArray[] = $this->factory->references('Column', $column);
		}
		$this->insert->columns($columnsArray);

		return $this;
	}
165129
public function columns($columns){
        if(is_array($columns)) $this->columns = array_merge($this->columns,$columns);
        return self::getInstance();
    }
588479
public function insert($table, array $columns)
    {
        if (empty($columns)) {
            return 0;
        }
        return $this->getInsertBuilder()
            ->setTable($table)
            ->setColumns($columns)
            ->execute();
    }
505489
public function first($columns = array('*'))
    {
        $results = $this->take(1)->get($columns)->current();

        return (isset($results[0]) && count($results[0]) > 0) ? $results[0]->getProperties() : null;
    }
990590
private function _calculateInputPlaceholders($columns)
	{
		// Make sure that we have at least one element
		if (!is_array($columns) || empty($columns) || count($columns) < 1)
		{
			Utility::throwException('Columns provided to calculate input placeholders are invalid.');
		}

		// Given the input array, just create an array that ranges from 1 to the number of items
		$numeric_array = range(1, count($columns));

		// For each value, precede the value with a dollar sign
		$numeric_array = array_map(
			function($num)
			{
				return '$' . $num;
			},
			$numeric_array
		);

		// Return the keyed array, with each parameter named by column
		return array_combine($columns, $numeric_array);
	}
857884
final public static function getTypedColumns($columns)
    {
        static::checkUnknownColumn($columns);

        $result = Utils::arrayWhitelist(
            array_combine(self::getColumns(), static::COLUMNS),
            (array) $columns
        );

        return (is_string($columns))
            ? array_values($result)[0]
            : $result;
    }
1200334
public function setColumns(array $columns)
    {
        $this->mappingColumns = null;
        $this->columns = array_values($columns);

        return $this;
    }
670181
public function getCountForPagination($columns = ['*'])
    {
        $this->backupFieldsForCount();

        $this->aggregate = ['function' => 'count', 'columns' => $this->clearSelectAliases($columns)];

        $results = $this->get();

        $this->aggregate = null;

        $this->restoreFieldsForCount();
        if (isset($this->groups)) {
            return count($results);
        }

        if (! isset($results[0])) {
            return 0;
        }

        $item = $results[0];

        if (is_object($item)) {
            return (int) $item->aggregate;
        }

        return (int) array_change_key_case((array) $item)['aggregate'];
    }
781137
public function setColumns(array $columns)
    {
        foreach ($columns as $column) {
            $this->columns->push($column);
        }

        return $this;
    }
803140
private function calculateNumberOfColumns($rows)
    {
        $columns = [0];
        foreach ($rows as $row) {
            if ($row instanceof TableSeparator) {
                continue;
            }

            $columns[] = $this->getNumberOfColumns($row);
        }

        $this->numberOfColumns = max($columns);
    }