Handle all substatements of `stmt`.
7722
def handle_substmts(self, stmt, p_elem, pset={}):
        """"""
        for sub in stmt.substmts:
            self.handle_stmt(sub, p_elem, pset)
357920
private function executeStatement($stmt) {

		if(true !== $stmt -> execute()) {

			if($this -> getLastErrno() > 0) {
				return trigger_error(sprintf('A database error occured with error number "%s" and message: "%s"', $this -> getLastErrno(), $this -> getLastError()), E_USER_ERROR);
			}

			return false;
		}

		$stmt -> store_result();

		return $stmt;
	}
1319921
async def execute(self, stmt, *args):
        
        with (await self.application.db.cursor()) as cur:
            await cur.execute(stmt, args)
735600
def n_exec_stmt(self, node):
        
        self.write(self.indent, 'exec ')
        self.preorder(node[0])
        if not node[1][0].isNone():
            sep = ' in '
            for subnode in node[1]:
                self.write(sep); sep = ", "
                self.preorder(subnode)
        self.println()
        self.prune()
642673
def execute(stmt, args=()):
    
    ctx = Context.current()
    with ctx.mdr:
        cursor = ctx.execute(stmt, args)
        row_count = cursor.rowcount
        _safe_close(cursor)
    return row_count
462923
def from_stmt(stmt, engine, **kwargs):
    
    result_proxy = engine.execute(stmt, **kwargs)
    return from_db_cursor(result_proxy.cursor)
480907
def add_stmt(stmt, arg_rules):
    """"""
    (arg, rules) = arg_rules
    stmt_map[stmt] = (arg, rules)
656031
def _prepare_if_args(stmt):
    """"""
    args = stmt['args']
    if args and args[0].startswith('(') and args[-1].endswith(')'):
        args[0] = args[0][1:].lstrip()
        args[-1] = args[-1][:-1].rstrip()
        start = int(not args[0])
        end = len(args) - int(not args[-1])
        args[:] = args[start:end]
404898
def visit_WhileStatement(self, node):
        """"""
        while self.visit(node.condition):
            result = self.visit(node.compound)
            if result is not None:
                return result
871272
def async_stmt_check(self, original, loc, tokens):
        """"""
        return self.check_py("35", "async for/with", original, loc, tokens)
286959
def stmt_lambda_name(self, index=None):
        """"""
        if index is None:
            index = len(self.stmt_lambdas)
        return stmt_lambda_var + "_" + str(index)
696942
private Status executeAssume(Stmt.Assume stmt, CallStack frame, EnclosingScope scope) {
		//
		checkInvariants(frame,stmt.getCondition());
		return Status.NEXT;
	}
65624
def p_foo_stmt(p):
    ""
    expr1 = p[1][1][0]
    expr2 = p[3][1][0]
    ident = expr1.ret
    args1 = expr1.args
    args2 = expr2.args
    p[0] = node.let(ret=ident,
                    args=node.expr("or", node.expr_list([args1, args2])))
1002114
private void pruneStatement(final Statement stmt, final Document doc) {
        final List<StatementGroup> stmtgroups = doc.getAllStatementGroups();
        for (final StatementGroup stmtgroup : stmtgroups) {
            final Iterator<Statement> sgi = stmtgroup.getStatements()
                    .iterator();
            while (sgi.hasNext()) {
                final Statement sgs = sgi.next();
                if (stmt.equals(sgs)) {
                    // prune
                    sgi.remove();
                    return;
                }
            }
        }
    }
233315
def _assemble_modification(stmt):
    """"""
    sub_str = _assemble_agent_str(stmt.sub)
    if stmt.enz is not None:
        enz_str = _assemble_agent_str(stmt.enz)
        if _get_is_direct(stmt):
            mod_str = ' ' + _mod_process_verb(stmt) + ' '
        else:
            mod_str = ' leads to the ' + _mod_process_noun(stmt) + ' of '
        stmt_str = enz_str + mod_str + sub_str
    else:
        stmt_str = sub_str + ' is ' + _mod_state_stmt(stmt)

    if stmt.residue is not None:
        if stmt.position is None:
            mod_str = 'on ' + ist.amino_acids[stmt.residue]['full_name']
        else:
            mod_str = 'on ' + stmt.residue + stmt.position
    else:
        mod_str = ''
    stmt_str += ' ' + mod_str
    return _make_sentence(stmt_str)
816175
def _execute(self, stmt, *values):
        
        c = self._cursor()
        try:
            return c.execute(stmt, values).fetchone()
        finally:
            c.close()
270040
private StmtTargetTableScan simplifierForSubquery(AbstractParsedStmt subquery) {
        // Must be a SELECT statement (not a SET operation)
        if (!(subquery instanceof ParsedSelectStmt)) {
            return null;
        }
        ParsedSelectStmt selectSubquery = (ParsedSelectStmt) subquery;
        // No aggregation and/or GROUP BY is allowed
        if (selectSubquery.hasAggregateOrGroupby()) {
            return null;
        }
        // No DISTINCT
        if (selectSubquery.hasAggregateDistinct()) {
            return null;
        }
        // No windowed aggregate functions like RANK.
        if (selectSubquery.hasWindowFunctionExpression()) {
            return null;
        }
        // No LIMIT/OFFSET
        if (selectSubquery.hasLimitOrOffset() || selectSubquery.hasLimitOrOffsetParameters()) {
            return null;
        }
        // Only SELECT from a single TARGET TABLE is allowed
        int tableCount = 0;
        StmtTargetTableScan simpler = null;
        for (Map.Entry<String, StmtTableScan> entry : selectSubquery.getScanEntrySet()) {
            if (entry.getKey().startsWith(AbstractParsedStmt.TEMP_TABLE_NAME)) {
                // This is an artificial table for a subquery expression
                continue;
            }
            if (++tableCount > 1) {
                return null;
            }
            // Only allow one TARGET TABLE, not a nested subquery.
            StmtTableScan scan = entry.getValue();
            if (scan instanceof StmtTargetTableScan) {
                simpler = (StmtTargetTableScan) scan;
            }
            else {
                return null;
            }
        }
        return simpler;
    }