I wonder if we should make it the responsibility of the partitioning implementation to strip the filename, instead of hardcoding an exception. (After all, what if the user wants to define a custom filename-based partitioning scheme?) Or we could pass both the path and the filename separately to partitioning->Parse.

So, it's like passing the entire info.path() in the Parse() method and then various partitioning implementations will do it in the way they want? I think we can then strip the prefix/filename in the ParseKeys method of each of the partitioning modes.

Yeah, I think we can still strip the prefix, but we can let the partitioning handle the rest.

And in that case it might make sense to split the remainder of the path and the filename for the partitioning implementation too and just pass both as arguments.

(We should still strip the prefix since presumably we don't want partitioning to depend on the prefix itself.)

We may pass both the filename and the path(other than the prefix) to the Parse() method, but the filename is only required for FilenamePartitioning I believe, and the path will be required by the Directory & Hive Partitioning.

Sure. From the point of view of datasets however it doesn't matter that some implementations only need some of the info.

CC @westonpace for thoughts

With the latest change, I modified the StripPrefixAndFilename() method to return a PartitionPathFormat object which will contain both the directory and filename prefix and then passing that to the Parse() method which now expects both the directory and filename-prefix.

We can modify the Parse() method as well to accept an object of PartitionPathFormat that way it will be symmetrical to the Format() method. But then, we need to implement similar changes to PyArrow, and I believe then we have to define an object of PartitionPathFormat first to use the partitioning.parse() method in PyArrow.

Why do we need the default parameter values?

Though yes, it would be better if we could pass const PartitionPathFormat& instead. FWIW I don't think we have to expose it to Python. Or we can just make a namedtuple on the Python side, it doesn't have to be a C++ class wrapper.

• Removed the default parameter
• Modified the Parse method to use a PartitionPathFormat object as an argument. As for the PyArrow interface, modified the parse() method to accept just the two strings (directory & prefix) and then uses a cppclass object to form the PartitionPathFormat object which is then passed into the internal Parse() method. Is this a good approach?

Why aren't we passing both components?

(Also, can we cover this with a test?)

Now that we are using the PartitionPathFormat as the argument, the Parse() method will work accordingly as per the partitioning mode. Any particular test you want here?

Making sure that a filename partitioning works properly in this path, basically, since before it seems like it would have failed since the filename was being omitted.

I have added a round-trip test in PyArrow to check whether the partitions are read correctly. Do we need any tests other than that?

Hmm, don't we still want the filename in the path in case the partitioning factory is a filename PartitioningFactory?

(Can we cover this with a test?)

This still seems off, but I can't figure out how to hit this case.

I think we can do the same changes in the Inspect() method which currently accepts a path. Instead of passing a vector of strings, we can then pass a vector of PartitionPathFormat object, and then the Inspect methods of individual partitioning modes will use either the directory or the filename accordingly?

That probably makes the most sense, but we might want to split out that refactoring separately, and also make sure that we can hit this path in a unit test in the first place (I was trying this morning but couldn't) as I don't want to expand the scope of this PR too much.

The Inspect() methods now accept a PartitionPathFormat object as an argument with the latest commit. I have modified the tests and SplitFilenameAndPrefix() methods to return forms of PartitionPathFormat object as required. The Inspect() methods then extracts the directory or prefix accordingly whichever is required.

With the changes in the Inspect() method, I think the R build is failing, I am trying to investigate on fixing it, but not very sure about the R implementation.

Hmm, not for this PR but I would expect FunctionPartitioning to be "as powerful as" any other partitioning. But I don't think it's used much anyways.

nit but do both of these need a default? I can see prefix having a default because it's a new argument

Also IMO the parameter should be named "filename", and/or we should have a docstring

Previously, when the parse() method only accepted a path, we used to pass the filename there, as FilenamePartitioning only needs the filename and not the directory. But, now that it is expecting both a directory and filename prefix, so I believe a directory will not be required for FilenamePartitioning, thus using an empty string as default.

Renamed prefix to filename in PartitionPathFormat

This still seems off, but I can't figure out how to hit this case.