Bash – Why does path-completion in bash not always work

This has not at all to do with bash, but it depends on the completions programmed in the package bash-completion.

From some comments in the file /etc/bash_completion.d/mount:

# mount(8) completion. This will pull a list of possible mounts out of
# /etc/{,v}fstab, unless the word being completed contains a ':', which
# would indicate the specification of an NFS server. In that case, we
# query the server for a list of all available exports and complete on
# that instead.
#

# umount(8) completion. This relies on the mount point being the third
# space-delimited field in the output of mount(8)
#

Also, you find in the main file /etc/bash_completion the following comment, that explicitly talk about mount and umount commands:

# A meta-command completion function for commands like sudo(8), which need to
# first complete on a command, then complete according to that command's own
# completion definition - currently not quite foolproof (e.g. mount and umount
# don't work properly), but still quite useful.
#

Update:
The comment about mount and umount commands was removed from bash_completion in the commit:

_command_offset: Restore compopts used by called command.

This fixes completions that rely on their compopts, most notably
mount(8).
Fixes bash-completion bug #313183.

Released in bash-completion 1.90

Bash's programmable completion works by parsing the command line and figuring out what is being completed:

1. Some contexts are treated specially, e.g. the first word in a command is completed as a command name, what follows a $ is completed as a variable name, etc.
2. Outside of these contexts, bash attempts to complete the argument of a command, and the settings for command or failing that (which is usually the case) for the basename of the command are applied.

For example, after sqllTab, bash completes command names that start with sqll. After sqlldr $aTab, bash completes variable names that start with a. After sqlldr Tab, bash applies the completion rules for the command sqlldr. Completion rules can specify a category (user, variable, files, etc.), a wildcard pattern for file names, or a function or code snippet to execute.

Completion rules are defined by the complete builtin. Bash doesn't keep track of when the complete builtin was called or what script (if any) it was in. Most distributions ship the bash-completion package, which provides a series of rules for common commands. This takes the form of a series of script files that contain calls to complete, with a script that must be read from .bashrc (or /etc/bash.bashrc if implemented) to load all of these scripts: typically . /etc/bash_completion is needed to activate programmable completion and load the available scripts.

The standard package does not include support for sqlldr. If you have such support, it must be coming from a different source. This source might have dropped a file in a directory like /etc/bash_completion.d or might have come with instructions to include some code in your .bashrc. You can use complete -p sqlldr to see the current rules for sqlldr; as mentioned before, this won't tell you where those rules were loaded from.

Tcsh, zsh and fish have somewhat similar mechanisms (everybody got their inspiration from tcsh) but different builtins, syntaxes and capabilities.