(TableName).nibbleDelete is cached in default procedure cache.
@param tableName
@return
16605
public ProcedureRunner getNibbleDeleteProc(String procName,
                                               Table catTable,
                                               Column column,
                                               ComparisonOperation op)
    {
        ProcedureRunner pr = m_defaultProcCache.get(procName);
        if (pr == null) {
            Procedure newCatProc =
                    StatementCompiler.compileNibbleDeleteProcedure(
                            catTable, procName, column, op);
            VoltProcedure voltProc = new ProcedureRunner.StmtProcedure();
            pr = new ProcedureRunner(voltProc, m_site, newCatProc);
            // this will ensure any created fragment tasks know to load the plans
            // for this plan-on-the-fly procedure
            pr.setProcNameToLoadForFragmentTasks(newCatProc.getTypeName());
            m_defaultProcCache.put(procName, pr);
            // also list nibble delete into default procedures
            m_defaultProcManager.m_defaultProcMap.put(procName.toLowerCase(), pr.getCatalogProcedure());
        }
        return pr;
    }
747222
public Crud<T, K> table(String table) {
        return new LazyCrud<T, K>(this, table);
    }
140709
@Override
  public Future<Void> truncateTableAsync(TableName tableName, boolean preserveSplits) throws IOException {
   if (!preserveSplits) {
      LOG.info("truncate will preserveSplits. The passed in variable is ignored.");
   }
   return FutureUtils.toCompletableFuture(
        tableAdminClientWrapper
          .dropAllRowsAsync(tableName.getNameAsString()));
  }
690592
public Table gethTable(final String tableName) throws IOException
    {
        return connection.getTable(TableName.valueOf(tableName));
    }
63996
@NonNull
  public static Drop dropTable(@NonNull String tableName) {
    return dropTable(CqlIdentifier.fromCql(tableName));
  }
609567
public int deleteByTableName(String tableName) throws SQLException {

		DeleteBuilder<Extensions, Void> db = deleteBuilder();

		db.where().eq(Extensions.COLUMN_TABLE_NAME, tableName);

		int deleted = db.delete();

		return deleted;
	}
882033
public int deleteByTableName(String tableName) throws SQLException {
		DeleteBuilder<ContentsId, Long> db = deleteBuilder();
		db.where().eq(ContentsId.COLUMN_TABLE_NAME, tableName);
		PreparedDelete<ContentsId> deleteQuery = db.prepare();
		int deleted = delete(deleteQuery);
		return deleted;
	}
115044
@NonNull
  public static Drop dropTable(@Nullable CqlIdentifier keyspace, @NonNull CqlIdentifier tableName) {
    return new DefaultDrop(keyspace, tableName, "TABLE");
  }
76104
protected Table getTableFromDB(String tableName) {
        Table table = m_db.getTables().getExact(tableName);
        return table;
    }
438796
public int delete(String tableName) {
		DeleteBuilder<GriddedTile, Long> db = deleteBuilder();

		int deleted = 0;

		try {
			db.where().eq(GriddedTile.COLUMN_TABLE_NAME, tableName);

			PreparedDelete<GriddedTile> deleteQuery = db.prepare();
			deleted = delete(deleteQuery);
		} catch (SQLException e) {
			throw new GeoPackageException(
					"Failed to delete Gridded Tile by Table Name: " + tableName,
					e);
		}

		return deleted;
	}
882733
public String generateSqlInsert(String tableName) {
        try {
            return cacheSQLs.get("INSERT:" + tableName, () -> {
                return MessageFormat.format("INSERT INTO {0} ({1}) VALUES ({2})", tableName,
                        strAllColumns, StringUtils.repeat("?", ",", getAllColumns().length));
            });
        } catch (ExecutionException e) {
            throw new DaoException(e);
        }
    }
67082
@Override
    public Object getTable(String tableName) {
	logger.debug("OMID Begin of getTable for " + tableName);
        TTable table = tableNameHandleMap.get(tableName);
        if (table != null) {
            logger.debug("OMIDE Found a cached handle for table " + tableName);
            return table;
        }
        try {
            table = new TTable(this.getHbcfg(), tableName);
        } catch (IOException e) {
            logger.error("OMID Error trying to get a TransactionTable of OMID.");
            logger.error(e.getMessage());
        }
        tableNameHandleMap.put(tableName, table);
        logger.debug("OMID Cached a handle of table: " + tableName);
        return table;
    }
1237995
@Override
    public java.util.concurrent.Future<DeleteItemResult> deleteItemAsync(String tableName, java.util.Map<String, AttributeValue> key) {

        return deleteItemAsync(new DeleteItemRequest().withTableName(tableName).withKey(key));
    }
1061701
public Table getTable(String tableName) {
    // [START ]
    Table table = dataset.get(tableName);
    // [END ]
    return table;
  }
951542
public static Mutation delete(String table, Key key) {
    return delete(table, KeySet.singleKey(key));
  }
219196
public void restoreTable(String tableName, String tempTableName) throws SQLException {
        LOG.debug("Restore table {} from {}", tableName, tempTableName);
        try {
            this.setForeignKeyCheckEnabled(false);
            this.truncateTable(tableName);
            final String sql = "INSERT INTO " + tableName + " SELECT * FROM " + tempTableName + ";";
            this.executeUpdate(sql);
        } finally {
            this.setForeignKeyCheckEnabled(true);
        }
    }
833618
@Override
	public String onColumnFullyQualifiedName(String tableName, String columnName) {
		if (onlyBindParameter)
			return null;

		return JQLReplacerListenerImpl.resolveFullyQualifiedColumnName(currentSchema, currentMethod, tableName, columnName);
	}