- Create table and insert rows
@param stdClass $variable Content variables for execute functionality
@return null
359712
public function table(stdClass $variable) {
    (new Table())->render($this->pdo, $this->info, $variable, $this->output);
  }
1260701
public function setRowKeys($var)
    {
        $arr = GPBUtil::checkRepeatedField($var, \Google\Protobuf\Internal\GPBType::BYTES);
        $this->row_keys = $arr;

        return $this;
    }
939944
public function add($variable)
    {
        return $this->wrap(new Operator\Addition($this, $this->asVariable($variable)));
    }
394405
public function setDeleteFromRow($var)
    {
        GPBUtil::checkMessage($var, \Google\Cloud\Bigtable\V2\Mutation_DeleteFromRow::class);
        $this->writeOneof(4, $var);

        return $this;
    }
915344
public function bind($columnID, &$variable): Statement
    {
        if (is_numeric($columnID)) {
            //PDO columns are 1-indexed
            $columnID = $columnID + 1;
        }

        $this->bindColumn($columnID, $variable);

        return $this;
    }
130862
private function execute(stdClass $data = null, $resourceId = null)
    {
        $body = empty($data) ? new stdClass() : $data;
        $response = $this->httpRequest($this->getPath($resourceId), Requests::POST, $body);

        return $this->populate($response);
    }
939896
public static function create($variable = 'Obj', $value = null)
        {
            $class = '\\PHY\\Variable\\'.$variable;
            if (class_exists($class)) {
                return new $class($value);
            } else {
                throw new \PHY\Variable\Exception('Could not find variable type of "'.$variable.'"');
            }
        }
143355
public function insert($table, $data = [])
    {
        // check if table name not empty
        if (!empty($table)) {
            // and array data not empty
            if (count($data) > 0 && is_array($data)) {
                // get array insert data in temp array
                $tmp = [];
                foreach ($data as $f => $v) {
                    $tmp[] = ":s_$f";
                }
                // make name space param for pdo insert statement
                $sNameSpaceParam = implode(',', $tmp);
                // unset temp var
                unset($tmp);
                // get insert fields name
                $sFields = implode(',', array_keys($data));
                // set pdo insert statement in class property
                $this->sql = "INSERT INTO `$table` ($sFields) VALUES ($sNameSpaceParam);";
                // pdo prepare statement
                $this->STH = $this->prepare($this->sql);
                // set class where property with array data
                $this->data = $data;
                // bind pdo param
                $this->_bindPdoNameSpace($data);
                // use try catch block to get pdo error
                try {
                    // execute pdo statement
                    if ($this->STH->execute()) {
                        // set class property with last insert id
                        $this->lastId = $this->lastInsertId();
                        // close pdo
                        $this->STH->closeCursor();
                        // return this object
                        return $this;
                    } else {
                        self::error($this->STH->errorInfo());
                    }
                } catch (\PDOException $e) {
                    // get pdo error and pass on error method
                    self::error($e->getMessage() . ': ' . __LINE__);
                }
            } else {
                self::error('Data not in valid format..');
            }
        } else {
            self::error('Table name not found..');
        }
    }
1261261
protected function _insert()
    {
        $result = parent::_insert();

        if ($result) {
            //also insert to multilang tables if it is separate
            foreach ($this->_getLanguageSetTables() as $table) {
                $sql = "insert into $table set " . $this->_getUpdateFieldsForTable($table, $this->getUseSkipSaveFields());

                $result = $result && (bool) $this->executeDatabaseQuery($sql);
            }
        }

        return $result;
    }
14430
public function addRow($data = null)
    {
        // Clear existing empty row
        if (($current = $this->currentRow()) && $current->isEmpty()) {
            array_pop($this->rows);
        }

        // Append data
        if ($data instanceof SQLAssignmentRow) {
            $this->rows[] = $data;
        } else {
            $this->rows[] = new SQLAssignmentRow($data);
        }
        return $this;
    }
551435
public function foreignKey(stdClass $variable) {
    (new ForeignKey())->render($this->pdo, $this->info, $variable, $this->output);
  }
818841
protected function createTable()
    {
        $template = file_get_contents(dirname(__FILE__) . '/TableSchema.sql');
        $this->pdo->query(sprintf($template, $this->table));
    }
728018
public function create(string $view, array $variables = []): View
	{
		[$path, $extension] = $this->getViewPathAndExtension($view);

		return new View($path, $this->mergeVariables($view, $variables), $this->resolveRenderer($extension));
	}
1223702
public function buildRow(
        array $row,
        $style = null,
        $rowIndex = 1
    ): void {
        if ($this->isNotInitialised()) {
            $this->initialise();
        }

        if ($style instanceof Style) {
            $this->writer->addRowWithStyle($row, $style);
        } else {
            $this->writer->addRow($row);
        }

        return;
    }
884197
public function execute(array $variables = null)
    {
        if (null === $variables) {
            $variables = $_SERVER;
        }

        $arguments = $this->arguments($variables);
        if (count($arguments) < 1) {
            throw new RuntimeException('No arguments provided.');
        }

        switch ($arguments[0]) {
            case '-h':
            case '--help':
                $this->executeUsage();

                return;

            case '-v':
            case '--version':
                $this->executeVersion();

                return;
        }

        $this->executeLaunch($arguments);
    }
388738
public function bindParam($parameter, &$variable, $data_type = PDO::PARAM_STR, $length = null, $driver_options = null) {
		$this->boundValues[$parameter] = $variable;
		return parent::bindParam($parameter, $variable, $data_type, $length, $driver_options);
	}
472884
public function merge(string $variable = null, array $labels = []): self
    {
        $query = new self;
        $query->clauses = $this->clauses->add(
            new Clause\MergeClause(
                Clause\Expression\Path::startWithNode($variable, $labels)
            )
        );

        return $query;
    }