is called only from Delete method and calls all delete relevant methods
executes the final SQL Delete Query.
429291
protected function DeleteExecute()
    {
        $oOrder = clone $this->oTable;
        $bReturn = parent::DeleteExecute();
        if (!empty($oOrder->sqlData['data_extranet_user_id'])) {
            $oTmpuser = TdbDataExtranetUser::GetNewInstance();
            $oTmpuser->Load($oOrder->sqlData['data_extranet_user_id']);
            if (!is_null($oTmpuser)) {
                TdbDataExtranetGroup::UpdateAutoAssignToUser($oTmpuser);
            }
        }

        return $bReturn;
    }
1331941
public int delete(DatabaseConnection databaseConnection, T data, ObjectCache objectCache) throws SQLException {
		if (mappedDelete == null) {
			mappedDelete = MappedDelete.build(dao, tableInfo);
		}
		int result = mappedDelete.delete(databaseConnection, data, objectCache);
		if (dao != null && !localIsInBatchMode.get()) {
			dao.notifyChanges();
		}
		return result;
	}
397473
protected void executeBatchAndClose(PreparedStatement... preparedStatements)
            throws SQLException {
        for (PreparedStatement ps : preparedStatements) {
            ps.executeBatch();
            ps.clearBatch();
            ps.close();
        }
    }
82102
public void removeThrow() throws SQLException {
		if (last == null) {
			throw new IllegalStateException("No last " + dataClass
					+ " object to remove. Must be called after a call to next.");
		}
		if (classDao == null) {
			// we may never be able to get here since it should only be null for queryForAll methods
			throw new IllegalStateException("Cannot remove " + dataClass + " object because classDao not initialized");
		}
		try {
			classDao.delete(last);
		} finally {
			// if we've try to delete it, clear the last marker
			last = null;
		}
	}
264704
public final void execute()
  {
    _log.debug( _sqlString );

    PreparedStatement lPreparedStatement = null;

    try
    {
      lPreparedStatement = _callableStatementProvider.createPreparedStatement( _sqlString );

      usePreparedStatement( lPreparedStatement );
    }
    catch( SQLException e )
    {
      if( !handleSQLException( e ) )
      {
        throw ExceptionManager.createException( e, _sqlString );
      }
    }
    finally
    {
      if( lPreparedStatement != null )
      {
        try
        {
          lPreparedStatement.close();
        }
        catch( SQLException eSQLException )
        {
          throw ExceptionManager.createException( eSQLException, _sqlString );
        }
      }
    }
  }
902651
@Override
    @Transactional
    public void run() {
        String storedProc = "purge_obsolete_batch_data";
        boolean result = entityManager.createStoredProcedureQuery(storedProc)
                                      .registerStoredProcedureParameter(0, Integer.class, ParameterMode.IN)
                                      .setParameter(0, 90)
                                      .execute();
        log.info("executed {} : resultset ? {}", storedProc, result);
    }
127971
private static int doDeleteAll(CallInfo callInfo, Table table) {
    DB db = table.getDB();
    return db.access(callInfo, () -> {
      String sql = DELETE_FROM_ + table.getName();
      db.logSetup(callInfo, sql);
      try (WrappedStatement ws = db.compile(sql)) {
        return ws.getStatement().executeUpdate();
      }
    });
  }
408053
protected function runSoftDelete()
    {
        $query = $this->newQueryWithoutScopes()->where($this->getKeyName(), $this->getKey());

        $this->{$this->getDeletedAtColumn()} = $time = $this->freshTimestamp();

        $query->update([$this->getDeletedAtColumn() => $this->fromDateTime($time)]);
    }
1358982
public void close() throws SQLException
	{
		more = false;
		if(!exclusive)
			return;
		if(rs != null)
		{
			rs.close();
			rs = null;
		}
		if(stmt != null)
		{
			stmt.close();
			stmt = null;
		}
	}
874651
def delete(self):
        
        (sql, ) = self._prepareSQL("DELETE")
        curs = self.cursor()
        curs.execute(sql, self._getID())
        curs.close()
        self.reset()
873390
@Override
	public boolean doProcedure(final SqlContext sqlContext, final CallableStatement callableStatement,
			final boolean result) throws SQLException {
		if (getFilters().isEmpty()) {
			return result;
		}
		boolean rs = result;
		for (final SqlFilter filter : getFilters()) {
			rs = filter.doProcedure(sqlContext, callableStatement, rs);
		}
		return rs;
	}
278492
def delete_by_query(query)
      rsp = post("<delete><query>#{query}</query></delete>")
      success?(rsp.body) or log_error(rsp.body)
    end
539257
protected function runSoftDelete()
    {
        $query = $this->newQuery()->where($this->getKeyName(), $this->getKey());

        $this->setAttribute($column = $this->getDeletedAtColumn(), $time = $this->freshTimestamp());

        $query->update(array($column => $this->fromDateTime($time)));
    }
760020
@Override
    public boolean execute(String sql) throws SQLException
    {
        checkClosed();
        VoltSQL query = VoltSQL.parseSQL(sql);
        return this.execute(query);
    }
1354822
public boolean execDelete(D6Model[] modelObjs) {

    if (modelObjs == null || modelObjs.length == 0) {
      return false;
    }

    boolean retVal = false;

    final D6CrudDeleteHelper dh = new D6CrudDeleteHelper(modelObjs[0].getClass());
    final String deleteSQL = dh.createDeletePreparedSQLStatement();

    log("#execDelete modelObjs=" + modelObjs + " delete SQL=" + deleteSQL);

    final Connection conn = createConnection();

    try {

      PreparedStatement preparedStmt = null;

      // There is a possibility that the error occurs in one single delete
      // statement.
      // Therefore, turn the auto commit off.
      conn.setAutoCommit(false);

      preparedStmt = conn.prepareStatement(deleteSQL);

      for (D6Model modelObj : modelObjs) {
        dh.map(modelObj, preparedStmt);

        // execute SQL
        preparedStmt.executeUpdate();
      }

      // Finally, commit.
      conn.commit();

      retVal = true;

    } catch (SQLException e) {

      loge("#execDelete", e);
      retVal = false;

    } catch (D6Exception e) {

      // catch from helper
      loge("#execDelete", e);
      retVal = false;

    } finally {
      try {
        conn.close();
      } catch (SQLException e) {
        retVal = false;
        loge("#execDelete", e);
      }
    }
    return retVal;

  }
1258054
final public void delete() {
		Transaction t = new Transaction();
		try {
			delete(t);
			t.setSuccessful(true);
		} finally {
			t.finish();
		}
	}
551129
public boolean execute() throws SQLException {
        boolean isExceptionThrown = ExecutorExceptionHandler.isExceptionThrown();
        SQLExecuteCallback<Boolean> executeCallback = SQLExecuteCallbackFactory.getPreparedSQLExecuteCallback(getDatabaseType(), isExceptionThrown);
        List<Boolean> result = executeCallback(executeCallback);
        if (null == result || result.isEmpty() || null == result.get(0)) {
            return false;
        }
        return result.get(0);
    }