dbms-docs-sec-5-6-7-added

Author: Vipullakum007

docs/DBMS/Indexing And Hashing/_category.json

@@ -0,0 +1,8 @@
+{
+    "label": "Indexing and Hashing",
+    "position": 5,
+    "link": {
+        "type": "generated-index",
+        "description": "Explore various indexing techniques and hashing methods in DBMS."
+    }
+}

docs/DBMS/Indexing And Hashing/hashing.md

@@ -0,0 +1,107 @@
+---
+id: dbms-hashing
+title: DBMS - Hashing
+sidebar_label: Hashing
+sidebar_position: 2
+description: Learn about different types of hashing in database management systems, their structures, and operations.
+---
+
+DBMS - Hashing
+===
+
+For a huge database structure, it can be almost next to impossible to search all the index values through all its levels and then reach the destination data block to retrieve the desired data. Hashing is an effective technique to calculate the direct location of a data record on the disk without using an index structure.
+
+Hashing uses hash functions with search keys as parameters to generate the address of a data record.
+
+Hash Organization
+---
+
+- **Bucket:** A hash file stores data in bucket format. A bucket is considered a unit of storage and typically stores one complete disk block, which in turn can store one or more records.
+- **Hash Function:** A hash function, h, is a mapping function that maps all the set of search-keys K to the address where actual records are placed. It is a function from search keys to bucket addresses.
+
+### Static Hashing
+
+In static hashing, when a search-key value is provided, the hash function always computes the same address. For example, if a mod-4 hash function is used, then it shall generate only 5 values. The output address shall always be the same for that function. The number of buckets provided remains unchanged at all times.
+
+#### Operation
+- **Insertion:** When a record is required to be entered using static hash, the hash function h computes the bucket address for search key K, where the record will be stored.
+  - Bucket address = h(K)
+- **Search:** When a record needs to be retrieved, the same hash function can be used to retrieve the address of the bucket where the data is stored.
+- **Delete:** This is simply a search followed by a deletion operation.
+
+```mermaid
+graph TD;
+    A[Static Hashing] --> B[Insertion]
+    A --> C[Search]
+    A --> D[Deletion]
+    B --> E[Compute Bucket Address]
+    C --> F[Retrieve Bucket Address]
+    D --> G[Locate and Delete Record]
+```
+
+#### Bucket Overflow
+The condition of bucket overflow is known as a collision. This is a critical state for any static hash function. In this case, overflow chaining can be used.
+
+- **Overflow Chaining:** When buckets are full, a new bucket is allocated for the same hash result and is linked after the previous one. This mechanism is called Closed Hashing.
+- **Linear Probing:** When a hash function generates an address at which data is already stored, the next free bucket is allocated to it. This mechanism is called Open Hashing.
+
+```mermaid
+graph TD;
+    A[Bucket Overflow] --> B[Overflow Chaining]
+    A --> C[Linear Probing]
+    B --> D[New Bucket Allocation]
+    C --> E[Next Free Bucket]
+```
+
+### Dynamic Hashing
+
+The problem with static hashing is that it does not expand or shrink dynamically as the size of the database grows or shrinks. Dynamic hashing provides a mechanism in which data buckets are added and removed dynamically and on-demand. Dynamic hashing is also known as extended hashing.
+
+#### Organization
+The prefix of an entire hash value is taken as a hash index. Only a portion of the hash value is used for computing bucket addresses. Every hash index has a depth value to signify how many bits are used for computing a hash function. These bits can address \(2^n\) buckets. When all these bits are consumed, that is, when all the buckets are full, then the depth value is increased linearly and twice the buckets are allocated.
+
+```mermaid
+graph TD;
+    A[Dynamic Hashing] --> B[Hash Index]
+    B --> C[Depth Value]
+    C --> D[Compute Bucket Addresses]
+    D --> E[Increase Depth and Allocate More Buckets]
+```
+
+#### Operation
+- **Querying:** Look at the depth value of the hash index and use those bits to compute the bucket address.
+- **Update:** Perform a query as above and update the data.
+- **Deletion:** Perform a query to locate the desired data and delete the same.
+- **Insertion:** Compute the address of the bucket.
+  - If the bucket is already full:
+    - Add more buckets.
+    - Add additional bits to the hash value.
+    - Re-compute the hash function.
+  - Else:
+    - Add data to the bucket.
+  - If all the buckets are full, perform the remedies of static hashing.
+
+```mermaid
+graph TD;
+    A[Dynamic Hashing Operation] --> B[Querying]
+    A --> C[Update]
+    A --> D[Deletion]
+    A --> E[Insertion]
+    E --> F[Compute Bucket Address]
+    F --> G{Bucket Full?}
+    G --> H[Add More Buckets]
+    G --> I[Add Data to Bucket]
+    H --> J[Add Bits to Hash Value]
+    H --> K[Re-compute Hash Function]
+```
+
+### Comparison Table
+
+| Feature            | Static Hashing            | Dynamic Hashing            |
+|--------------------|---------------------------|----------------------------|
+| Bucket Expansion   | Fixed number of buckets   | Buckets expand/shrink dynamically |
+| Collision Handling | Overflow chaining, linear probing | Overflow chaining, linear probing |
+| Performance        | Good for small databases  | Better for large, dynamic databases |
+| Flexibility        | Less flexible             | Highly flexible            |
+
+Hashing is not favorable when the data is organized in some ordering and the queries require a range of data. When data is discrete and random, hashing performs the best. Hashing algorithms have higher complexity than indexing. All hash operations are done in constant time.

docs/DBMS/Indexing And Hashing/indexing.md

@@ -0,0 +1,135 @@
+---
+id: dbms-indexing
+title: DBMS - Indexing
+sidebar_label: Indexing
+sidebar_position: 1
+description: Learn about different types of indexing in database management systems, their structures, and operations.
+---
+
+DBMS - Indexing
+===
+
+We know that data is stored in the form of records. Every record has a key field, which helps it to be recognized uniquely.
+
+Indexing is a data structure technique to efficiently retrieve records from the database files based on some attributes on which the indexing has been done. Indexing in database systems is similar to what we see in books.
+
+Indexing Types
+---
+
+Indexing is defined based on its indexing attributes. Indexing can be of the following types:
+
+### Primary Index
+- **Description:** Defined on an ordered data file. The data file is ordered on a key field, generally the primary key of the relation.
+
+### Secondary Index
+- **Description:** May be generated from a field which is a candidate key and has a unique value in every record, or a non-key with duplicate values.
+
+### Clustering Index
+- **Description:** Defined on an ordered data file. The data file is ordered on a non-key field.
+
+Ordered Indexing Types
+---
+
+Ordered Indexing can be of two types:
+
+### Dense Index
+- **Description:** There is an index record for every search key value in the database.
+- **Characteristics:** Faster searching but requires more space to store index records.
+- **Structure:**
+    - Index records contain search key value and a pointer to the actual record on the disk.
+
+```mermaid
+graph TD;
+    A[Dense Index] --> B[Search Key 1]
+    A --> C[Search Key 2]
+    A --> D[Search Key 3]
+    B --> E[Record Pointer 1]
+    C --> F[Record Pointer 2]
+    D --> G[Record Pointer 3]
+```
+
+### Sparse Index
+- **Description:** Index records are not created for every search key.
+- **Characteristics:** Contains a search key and an actual pointer to the data on the disk.
+- **Structure:**
+    - To search a record, proceed by index record and reach the actual location of the data. If not found, start sequential search until the desired data is found.
+
+```mermaid
+graph TD;
+    A[Sparse Index] --> B[Search Key 1]
+    A --> C[Search Key 2]
+    A --> D[Search Key 3]
+    B --> E[Record Pointer 1]
+    C --> F[Record Pointer 2]
+    D --> G[Record Pointer 3]
+```
+
+### Multilevel Index
+- **Description:** Index records comprise search-key values and data pointers. Stored on disk along with the actual database files.
+- **Characteristics:** As the database size grows, so does the size of the indices.
+- **Structure:**
+    - Break down the index into several smaller indices to make the outermost level so small that it can be saved in a single disk block.
+
+```mermaid
+graph TD;
+    A[Multilevel Index] --> B[Level 1 Index]
+    B --> C[Level 2 Index 1]
+    B --> D[Level 2 Index 2]
+    C --> E[Data Pointer 1]
+    C --> F[Data Pointer 2]
+    D --> G[Data Pointer 3]
+    D --> H[Data Pointer 4]
+```
+
+### B+ Tree
+- **Description:** A balanced binary search tree that follows a multi-level index format. Leaf nodes denote actual data pointers.
+- **Characteristics:** Ensures all leaf nodes remain at the same height, thus balanced. Supports random access and sequential access.
+
+```mermaid
+graph TD;
+    A[B+ Tree] --> B[Internal Node]
+    B --> C[Leaf Node 1]
+    B --> D[Leaf Node 2]
+    C --> E[Data Pointer 1]
+    C --> F[Data Pointer 2]
+    D --> G[Data Pointer 3]
+    D --> H[Data Pointer 4]
+    H --> I[Next Leaf Node]
+```
+
+#### Structure of B+ Tree
+- **Internal Nodes:**
+    - Contain at least ⌈n/2⌉ pointers, except the root node.
+    - At most, an internal node can contain n pointers.
+
+- **Leaf Nodes:**
+    - Contain at least ⌈n/2⌉ record pointers and ⌈n/2⌉ key values.
+    - At most, a leaf node can contain n record pointers and n key values.
+    - Every leaf node contains one block pointer P to point to the next leaf node, forming a linked list.
+
+#### B+ Tree Insertion
+1. **Insertion at Leaf Node:**
+    - If a leaf node overflows, split node into two parts.
+    - Partition at i = ⌊(m+1)/2⌋.
+    - First i entries are stored in one node.
+    - Rest of the entries (i+1 onwards) are moved to a new node.
+    - ith key is duplicated at the parent of the leaf.
+
+2. **Insertion at Non-leaf Node:**
+    - Split node into two parts.
+    - Partition the node at i = ⌈(m+1)/2⌉.
+    - Entries up to i are kept in one node.
+    - Rest of the entries are moved to a new node.
+
+#### B+ Tree Deletion
+1. **Deletion at Leaf Node:**
+    - The target entry is searched and deleted.
+    - If it is an internal node, delete and replace it with the entry from the left position.
+    - After deletion, check for underflow.
+
+2. **Handling Underflow:**
+    - If underflow occurs, distribute the entries from the nodes left to it.
+    - If distribution is not possible from the left, distribute from the nodes right to it.
+    - If distribution is not possible from left or right, merge the node with left and right nodes.
+
+In summary, indexing in DBMS is a crucial technique to enhance the speed and efficiency of data retrieval. Different indexing methods and structures are suited to various data and query types, ensuring optimized performance for diverse database operations.

docs/DBMS/Storage And File Structure/_category.json

@@ -0,0 +1,8 @@
+{
+    "label": "Storage and Joins",
+    "position": 4,
+    "link": {
+        "type": "generated-index",
+        "description": "Explore various storage techniques and join operations in DBMS."
+    }
+}

docs/DBMS/Storage And File Structure/dbms-file-structure.md

@@ -0,0 +1,96 @@
+---
+id: dbms-file-structure
+title: DBMS - File Structure
+sidebar_label: File Structure
+sidebar_position: 2
+description: Explore the different types of file structures in database management, including file organization methods and file operations.
+---
+
+DBMS - File Structure
+---
+
+Relative data and information are stored collectively in file formats. A file is a sequence of records stored in binary format. A disk drive is formatted into several blocks that can store records. File records are mapped onto those disk blocks.
+
+File Organization
+---
+
+File Organization defines how file records are mapped onto disk blocks. We have four types of File Organization to organize file records:
+
+### Heap File Organization
+- **Description:** When a file is created using Heap File Organization, the Operating System allocates memory area to that file without any further accounting details. File records can be placed anywhere in that memory area.
+- **Characteristics:** No ordering, sequencing, or indexing.
+- **Responsibility:** Software manages the records.
+
+### Sequential File Organization
+- **Description:** Records are placed in the file in some sequential order based on a unique key field or search key.
+- **Characteristics:** Practically, not all records can be stored sequentially in physical form.
+- **Example:** Library cataloging system where books are stored based on a unique identifier.
+
+### Hash File Organization
+- **Description:** Uses Hash function computation on some fields of the records. The output of the hash function determines the location of the disk block where the records are to be placed.
+- **Characteristics:** Efficient for retrieval when the search is based on the hashed attribute.
+- **Example:** Student records where student ID is used to determine storage location.
+
+### Clustered File Organization
+- **Description:** Related records from one or more relations are kept in the same disk block.
+- **Characteristics:** Not based on primary key or search key.
+- **Use Case:** Used when accessing related data together.
+
+```mermaid
+graph TD;
+    A[File Organization] --> B[Heap File Organization]
+    A --> C[Sequential File Organization]
+    A --> D[Hash File Organization]
+    A --> E[Clustered File Organization]
+```
+
+File Operations
+---
+
+Operations on database files can be broadly classified into two categories:
+
+1. **Update Operations**
+    - **Description:** Change data values by insertion, deletion, or update.
+
+2. **Retrieval Operations**
+    - **Description:** Retrieve data without altering it, potentially with optional conditional filtering.
+
+### Common File Operations
+- **Open:** 
+    - **Modes:** Read mode (data is read-only) and Write mode (data modification allowed).
+    - **Characteristics:** Files in read mode can be shared; files in write mode cannot be shared.
+
+- **Locate:**
+    - **Description:** File pointer tells the current position where data is to be read or written.
+    - **Function:** Can be moved forward or backward using find (seek) operation.
+
+- **Read:**
+    - **Description:** By default, the file pointer points to the beginning of the file when opened in read mode.
+    - **Characteristics:** User can specify where to locate the file pointer.
+
+- **Write:**
+    - **Description:** Enables editing file contents, including deletion, insertion, or modification.
+    - **Characteristics:** File pointer can be dynamically changed if allowed by the operating system.
+
+- **Close:**
+    - **Description:** Crucial for the operating system.
+    - **Function:**
+        1. Removes all locks if in shared mode.
+        2. Saves data to secondary storage if altered.
+        3. Releases all buffers and file handlers associated with the file.
+
+```mermaid
+graph TD;
+    A[File Operations] --> B[Update Operations]
+    A --> C[Retrieval Operations]
+    B --> D[Insert]
+    B --> E[Delete]
+    B --> F[Update]
+    C --> G[Select]
+    C --> H[Filter]
+```
+
+The organization of data inside a file plays a major role in how efficiently these operations can be performed. The method used to locate the file pointer to a desired record inside a file varies based on whether the records are arranged sequentially or clustered.
+
+In summary, understanding the various file structures and their operations is crucial for efficient database management, ensuring optimal performance and reliability.
+```