Get data from the temporary table

@return  Mixed $data
@throws  Exception
322125
public function getTemporary()
	{
		// disable query logging
		$connection_name = Config::get('laravel-import-export::baseconf.connection_name');
		DB::connection($connection_name)->disableQueryLog();
		$temporary = TemporaryModel::whereRaw("1")->orderBy("id","DESC")->first();
		if($temporary)
		{
				$this->csv_file =  $temporary->file_object;
				return $this->csv_file;
		}
		return false;
	}
209726
public function fetch()
        {
            try {
                if ($this->values = $this->statement->fetch(\PDO::FETCH_ASSOC)) {
                    return $this->values;
                } else {
                    return false;
                }
            } catch (\PDOException $e) {
                throw new Exception('An error occured while trying to fetch the result: "' . $e->getMessage() . '"');
            }
        }
439899
public function getData()
    {
        if (!$this->data) {
            // Convert the appropriate fields to integer.
            $this->data = (object) $this->rawData;
            $int_fields = $this->getIntegerFields();
            foreach ($int_fields as $field) {
                $this->data->$field = (int) $this->data->$field;
            }
        }

        return $this->data;
    }
60568
private function _getCurrentData()
    {
        $cls = $this->_cls;
        if (!$this->_data) {
            $this->_data = $cls::executePrepared($this->_builder, $this->_vals);
        }
        return $this->_data->fetch(\PDO::FETCH_ASSOC);
    }
248132
protected function fetchData() {
    if (!$this->data) {
      $this->data = $this->parser->parseFileFromModule($this->getSource(), $this->getModule(), $this->getProfile());
    }

    return $this->data;
  }
812051
public function offsetGet($offset)
    {
        $data = $this->getQueryResult($offset);
        if (null == $data) {
            throw new Exception('Data row by key "' . $offset . '" not exists');
        }
        return $data;
    }
574711
protected function getTableData()
	{
		$data = array();
		$form_input = $this->getFormInput();

		if( $form_input['table_name'] && $form_input['max_rows'] )
		{
			$connection_name = Config::get('laravel-import-export::baseconf.connection_name');
			$temp_data = DB::connection($connection_name)
				->table($this->form_input['table_name'])
				->select("*")
				->take($this->form_input['max_rows']);
			if( $temp_data->exists() )
			{
				$data = $temp_data->get();
			}
			else
			{
				throw new NoDataException;
			}
		}
		else
		{
			throw new \BadMethodCallException;
		}

		return $data;
	}
772763
public function getData() {
		if ($this->_tempFileName == '') {
			return $this->_xmlWriter->outputMemory(true);
		} else {
			$this->_xmlWriter->flush();
			return file_get_contents($this->_tempFileName);
		}
	}
85253
public function getDataSource()
    {
        if (empty($this->dataSource)) {
            // Assign the default data source, now that one is needed.
            $this->dataSource = $this->getDefaultDataSource();
            // If, after assigning the data source, there is still nothing in
            // the property, then fail.
            if (empty($this->dataSource)) {
                throw new Exception('No datasource has been defined.');
            }
        }

        return $this->dataSource;
    }
309673
public function getData()
    {
        if (is_null($this->data)) {
            $this->data = $this->index->getParser()->getData($this->getOffset());
            
        }
        return $this->data;
    }
890169
public function readTable()
    {
        $this->_bitcount = $this->_bits = 0;
        $tlen = $this->readPhpInt();
        if ($tlen < 0) {
            throw new \Exception('Table is longer than supported');
        }
        $tableData = new Reader($this->_rawread($tlen));
        $result = array();
        while ($tableData->tell() < $tlen) {
            $name = $tableData->readShortstr();
            $ftype = $tableData->_rawread(1);
            if ($ftype == 'S') {
                $val = $tableData->readLongstr();
            } else if ($ftype == 'I') {
                $val = $tableData->_readSignedLong();
            } else if ($ftype == 'D') {
                $e = $tableData->readOctet();
                $n = $tableData->_readSignedLong();
                $val = new Decimal($n, $e);
            } else if ($ftype == 'T') {
                $val = $tableData->readTimestamp();
            } else if ($ftype == 'F') {
                $val = $tableData->readTable(); // recursion
            } else {
                error_log(sprintf('Usupported table field type %s', $ftype));
                $val = null;
            }
            $result[ $name ] = array( $ftype, $val );
        }
        return $result;
    }
1257040
public function getData()
    {
        if (isset($this->functions) || isset($this->constructor)) {
            $arguments = func_get_args();
            $functionData = '';

            if (empty($this->toAddress) && !empty($this->bytecode)) {
                $constructor = $this->constructor;

                if (count($arguments) < count($constructor['inputs'])) {
                    throw new InvalidArgumentException('Please make sure you have put all constructor params and callback.');
                }
                if (!isset($this->bytecode)) {
                    throw new \InvalidArgumentException('Please call bytecode($bytecode) before getData().');
                }
                $params = array_splice($arguments, 0, count($constructor['inputs']));
                $data = $this->ethabi->encodeParameters($constructor, $params);
                $functionData = $this->bytecode . Utils::stripZero($data);
            } else {
                $method = array_splice($arguments, 0, 1)[0];

                if (!is_string($method)) {
                    throw new InvalidArgumentException('Please make sure the method is string.');
                }
    
                $functions = [];
                foreach ($this->functions as $function) {
                    if ($function["name"] === $method) {
                        $functions[] = $function;
                    }
                };
                if (count($functions) < 1) {
                    throw new InvalidArgumentException('Please make sure the method exists.');
                }
    
                $params = $arguments;
                $data = "";
                $functionName = "";
                foreach ($functions as $function) {
                    if (count($arguments) !== count($function['inputs'])) {
                        continue;
                    }
                    try {
                        $data = $this->ethabi->encodeParameters($function, $params);
                        $functionName = Utils::jsonMethodToString($function);
                    } catch (InvalidArgumentException $e) {
                        continue;
                    }
                    break;
                }
                if (empty($data) || empty($functionName)) {
                    throw new InvalidArgumentException('Please make sure you have put all function params and callback.');
                }
                $functionSignature = $this->ethabi->encodeFunctionSignature($functionName);
                $functionData = Utils::stripZero($functionSignature) . Utils::stripZero($data);
            }
            return $functionData;
        }
    }
973843
function get_data() {
        $data = parent::get_data();

        if ($data !== null and isset($data->description)) {
            $data->descriptionformat = $data->description['format'];
            $data->description = $data->description['text'];
        }

        return $data;
    }
1028601
public function getData()
    {
        try {
            $this->parse();
            $organized_statements = array();
            foreach ($this->dependencies as $name=>$preset) {
                foreach ($preset->getStatements() as $type=>$statements) {
                    if (!isset($organized_statements[$type])) {
                        $organized_statements[$type] = array();
                    }
                    foreach ($statements as $statement) {
                        $organized_statements[$type][] = $statement;
                    }
                }
            }
            foreach ($organized_statements as $type=>$stacks) {
                $organized_statements[$type] = $preset->getOrderedStatements($stacks);
            }
        } catch (\Exception $e) {
            throw $e;
        }
        return $organized_statements;
    }
1123583
public function get_data() {
        $data = parent::get_data();
        if ($data && $this->hascustomrules) {
            $this->get_module_form()->data_postprocessing($data);
        }
        return $data;
    }
168417
protected function transform($data)
    {
        if (!$data instanceof GetSchema\Schema) {
            throw new Exception('Data is not a Schema.');
        }

        $createExpr = $this->getCreateQueryFromSchema($data);
        $indices = $createExpr->getIndices();
        $columns = $createExpr->getColumns();

        $returnData = [];

        /* @var  $column Query\ColumnExpression */
        foreach ($columns as $column) {
            $row                      = self::$tplData;
            $columnType               = $column->getColumnType();
            $dataType                 = $columnType->getDataType();

            $key = $this->getKeyTypeFromColumn($column, $indices);
            $default = $this->getDefaultValueFromColumnType($columnType);

            $row[self::KEY_FIELD]     = $row[0] = $column->getColumnName();
            $row[self::KEY_TYPE]      = $row[1] = $columnType->getSqlType();
            $row[self::KEY_COLLATION] = $row[2] = $dataType->getCollation() !== '' ? $dataType->getCollation() : null;
            $row[self::KEY_NULL]      = $row[3] = $columnType->isNullable() ? 'YES' : 'NO';
            $row[self::KEY_KEY]       = $row[4] = $key;
            $row[self::KEY_DEFAULT]   = $row[5] = $default;

            $returnData[] = $row;
        }

        return $returnData;
    }
229569
public function get_data() {
        $data = parent::get_data();
        if (is_object($data)) {
            foreach (static::$fieldstoremove as $field) {
                unset($data->{$field});
            }
            $data = static::convert_fields($data);

            // Ensure that the ID is set.
            $data->id = $this->persistent->get('id');
        }
        return $data;
    }