Large Folder Operations in Cloud Collaboration via Partitioning
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Legacy approaches for performing large folder operations in cloud-based environments face issues with transaction latency, collaborator efficiency, and resource usage, leading to increased lock contention and inefficiencies in managing large sets of objects shared by many collaborators.
Innovation Solution
The techniques involve partitioning large folder operations into multiple database transactions using cloud-based metadata to facilitate transaction execution and collaborator accessibility, allowing for concurrent access and reducing the demand on computer resources and inter-component communication.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If a single database transaction is used for large folder operations, then transaction completeness is ensured, but transaction latency increases and collaborator access is blocked
Solution Approach 1:
The patent divides a large folder operation into multiple smaller database transactions by partitioning the set of items into subsets. Each subset is processed in a separate transaction, reducing the duration of individual transactions while maintaining overall operation completeness. The system iterates through partitions, applying the folder operation to each subset sequentially.
2Reliability
If locks are enforced on objects during a large folder operation, then data consistency is maintained, but collaborator efficiency decreases due to limited access
Solution Approach 1:
By segmenting the folder operation into multiple smaller transactions on partitioned subsets, the lock duration on any single subset is significantly reduced. Collaborators can access and modify items in subsets that are not currently being processed, improving overall collaborator efficiency while maintaining data consistency through proper lock management on active subsets.
3Reliability
If multiple concurrent locks are maintained for large folder operations, then operation safety is ensured, but database performance decreases due to lock contention
Solution Approach 1:
The patent reduces lock contention by processing items in smaller partitioned subsets rather than locking all items simultaneously. This segmentation allows for fewer concurrent locks to be maintained at any given time, improving database performance while still ensuring operation safety through proper transaction management and commit protocols.
4Reliability
If user limits are applied to the number of objects in a folder, then database transaction capabilities are protected, but content management efficacy is reduced
Solution Approach 1:
The system removes artificial user-imposed limits on folder size by implementing automatic partitioning of large item sets. This allows the database to handle arbitrarily large folder operations by dividing them into manageable transactions, enhancing content management efficacy while protecting database transaction capabilities through proper partition management and iterative processing.
Data Source
AI summary
Systems for managing operating on folders that comprise a large number of objects in a cloud-based collaboration platform. A cloud-based environment includes storage devices that store content objects accessible by collaborating users. The content objects are identified by one or more hierarchical path identifiers comprising a folder identifier corresponding to a logical grouping. The hierarchical path identifiers are stored in a relational database. Methods receive an operation command from a user to operate on the content objects associated with the logical grouping, after which a relational database search query is generated. Processing of the query returns a plurality of result sets corresponding to respective portions of the content objects associated with the logical grouping. The operation command is applied iteratively over the plurality of result sets, and the command is finalized after the last iteration. Collaborators can perform certain operations on content objects even while the iterations are in progress.