SQL for deleting a row on the lock table.
778814
private static String getDeleteLockSql() {
        if (deleteLockSql == null) {
            deleteLockSql =
                    "DELETE FROM "
                            + LOCK_TABLE
                            + " WHERE "
                            + ENTITY_TYPE_COLUMN
                            + EQ
                            + "?"
                            + " AND "
                            + ENTITY_KEY_COLUMN
                            + EQ
                            + "?"
                            + " AND "
                            + EXPIRATION_TIME_COLUMN
                            + EQ
                            + "?"
                            + " AND "
                            + LOCK_TYPE_COLUMN
                            + EQ
                            + "?"
                            + " AND "
                            + LOCK_OWNER_COLUMN
                            + EQ
                            + "?";
        }
        return deleteLockSql;
    }
445907
void remove(int row, int column) {
        SparseArrayCompat<TObj> array = mData.get(row);
        if (array != null) {
            array.remove(column);
        }
    }
147607
def delete(sql_params = "", *bindvars)
      delete_sql = "DELETE FROM \"#{@schema_name}\".\"#{@table_name}\" "
      case sql_params
      when String
        delete_sql << sql_params
      when Hash
        raise ArgumentError, "Cannot specify bind variables when passing WHERE conditions as Hash" unless bindvars.empty?
        where_sqls = []
        sql_params.each do |k, v|
          where_sqls << "#{k} = :#{k}"
          bindvars << v
        end
        delete_sql << "WHERE " << where_sqls.join(" AND ") unless where_sqls.empty?
      else
        raise ArgumentError, "Only String or Hash can be provided as SQL condition argument"
      end
      @schema.execute(delete_sql, *bindvars)
    end
251976
private void deleteNoCheck(Session session, Row row) {

        if (row.isDeleted(session)) {
            return;
        }

        session.addDeleteAction(this, row);
    }
802139
def remove_lock(self):
        
        key = '%s_lock' % self.scheduler_key

        if self._lock_acquired:
            self.connection.delete(key)
310411
protected void deleteRecord(Connection connection, String hash)
            throws SQLException {
        int id = selectRecordId(hash);
        if (id > 0) {
            String[] queries = new String[] { Query.DELETE_FILEHASHES,
                    Query.DELETE_METAS, Query.DELETE_CVES,
                    Query.DELETE_RECORD_ID };
            for (String query : queries) {
                PreparedStatement ps = setObjects(connection, query, id);
                ps.execute();
                ps.close();
            }
        }
    }
1090773
def remove(self, row):
        
        self._rows.remove(row)
        self._deleted_rows.add(row)
1173120
protected void deleteCurrentRowData() throws SQLException {
    //move data
    System.arraycopy(data, rowPointer + 1, data, rowPointer, dataSize - 1 - rowPointer);
    data[dataSize - 1] = null;
    dataSize--;
    lastRowPointer = -1;
    previous();
  }
449837
def delete(self, table, where=None, commit=True):
        
        where_q, _args = self._where_parser(where)

        alias = self._tablename_parser(table)['alias']

        _sql = ''.join(['DELETE ',
                        alias + ' ' if alias else '',
                        'FROM ', self._tablename_parser(table)['formatted_tablename'], where_q, ';'])

        if self.debug:
            return self.cur.mogrify(_sql, _args)

        result = self.cur.execute(_sql, _args)
        if commit:
            self.commit()
        return result
1041456
public int delete(String sql, Object value) {
        Class<?> parameterType = value != null ? value.getClass() : null;
        String msId = msUtils.deleteDynamic(sql, parameterType);
        return sqlSession.delete(msId, value);
    }
189734
def delete(self):
        
        cmd = "delete from {table} {where_clause}".format(
            table=self.table_name,
            where_clause=self.where_clause
        ).rstrip()
        Repo.db.execute(cmd, self.where_values)
735229
public void bindDelete(PreparedStatement stmt, ClassDescriptor cld, Object obj) throws SQLException
    {
        if (cld.getDeleteProcedure() != null)
        {
            this.bindProcedure(stmt, cld, obj, cld.getDeleteProcedure());
        }
        else
        {
            int index = 1;
            ValueContainer[] values, currentLockingValues;

            currentLockingValues = cld.getCurrentLockingValues(obj);
            // parameters for WHERE-clause pk
            values = getKeyValues(m_broker, cld, obj);
            for (int i = 0; i < values.length; i++)
            {
                setObjectForStatement(stmt, index, values[i].getValue(), values[i].getJdbcType().getType());
                index++;
            }

            // parameters for WHERE-clause locking
            values = currentLockingValues;
            for (int i = 0; i < values.length; i++)
            {
                setObjectForStatement(stmt, index, values[i].getValue(), values[i].getJdbcType().getType());
                index++;
            }
        }
    }
234134
def delete(key, profile=None):
    '''
    
    '''
    if not profile:
        return None
    conn, cur, table = _connect(profile)
    q = profile.get('delete_query', ('DELETE FROM {0} WHERE '
                                     'key=:key'.format(table)))
    res = cur.execute(q, {'key': key})
    conn.commit()
    return cur.rowcount
33703
private BoundStatement addRowDelete(String tableName, String key) {
        PreparedStatement prepState = m_dbservice.getPreparedUpdate(Update.DELETE_ROW, tableName);
        BoundStatement boundState = prepState.bind();
        boundState.setString(0, key);
        return boundState;
    }
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();
      }
    });
  }
987547
def delete(self, entry):
        
        c = self.conn.cursor()
        c.execute("DELETE FROM oath WHERE key = ?", (entry.data["key"],))
235285
void deleteNoRefCheck(Session session, Row row) {

        Object[] data = row.getData();

        fireBeforeTriggers(session, Trigger.DELETE_BEFORE, data, null, null);

        if (isView) {
            return;
        }

        deleteNoCheck(session, row);
    }