Interview Questions
CASE statements in WHERE clauses allow for complex conditional logic. For example: WHERE CASE WHEN price > 100 THEN discount ELSE full_price END > 50. This enables dynamic comparison values based on multiple conditions.
LIKE uses simple wildcard patterns with % and _, while REGEXP enables complex pattern matching using regular expressions. REGEXP provides more powerful pattern matching capabilities including character classes, repetitions, and alternations.
Fuzzy matching can be implemented using functions like SOUNDEX, LEVENSHTEIN distance, or custom string similarity functions. These help find approximate matches when exact matching isn't suitable, useful for handling typos or variations in text.
BETWEEN tests if a value falls within a range, inclusive of boundaries. It handles different data types (numbers, dates, strings) appropriately, but care must be taken with timestamps and floating-point numbers for precise comparisons.
Related records can be filtered using EXISTS/NOT EXISTS, IN/NOT IN with subqueries, or LEFT JOIN with NULL checks. EXISTS often performs better for large datasets as it stops processing once a match is found.
NULL values require special handling: IS NULL/IS NOT NULL for direct comparison, COALESCE/NULLIF for substitution, and careful consideration with NOT IN operations as NULL affects their logic differently than normal values.
Array containment can be checked using ANY/ALL operators, ARRAY_CONTAINS function (in supported databases), or JSON array functions. For databases without native array support, you might need to split strings or use junction tables.
WHERE filters individual rows before grouping and cannot use aggregate functions, while HAVING filters groups after aggregation and can use aggregate functions. HAVING is specifically designed for filtering grouped results.
Dynamic filtering can be implemented using CASE statements, dynamic SQL with proper parameterization, or by building WHERE clauses conditionally. Always use parameterized queries to prevent SQL injection.
Window functions like ROW_NUMBER, RANK, or LAG can be used in subqueries or CTEs to filter based on row position, ranking, or comparison with adjacent rows. They're useful for tasks like finding top N per group.
Temporal filtering uses date/time functions and operators to handle ranges, overlaps, and specific periods. Consider timezone handling, date arithmetic, and proper indexing for performance.
Performance varies based on indexing, data distribution, and filter complexity. Using appropriate indexes, avoiding functions on indexed columns, and choosing the right operators (EXISTS vs IN) can significantly impact performance.
Hierarchical filtering uses recursive CTEs to traverse parent-child relationships. The recursive query combines a base case with a recursive step to filter based on tree structures like organizational charts.
Bitmap indexes are specialized indexes that work well for low-cardinality columns. They can improve filtering performance on multiple conditions through bitmap operations, but may not be suitable for frequently updated data.
JSON data can be filtered using JSON path expressions, JSON extraction functions, and comparison operators. Different databases provide specific functions like JSON_VALUE, JSON_QUERY, or ->> operators for JSON manipulation.
Indexes support efficient data retrieval in filtering operations. Composite indexes, covering indexes, and filtered indexes can be designed to optimize specific filtering patterns and improve query performance.
Overlapping ranges can be handled using combinations of comparison operators, BETWEEN, or specialized range types. Consider edge cases and ensure proper handling of inclusive/exclusive bounds.
Best practices include using appropriate indexes, avoiding functions on filtered columns, considering partitioning, using efficient operators, and implementing pagination or batch processing for large result sets.
Full-text search can be implemented using full-text indexes, CONTAINS/FREETEXT predicates, or specialized functions. Consider relevance ranking, word stemming, and stop words for effective text search.
Subqueries and joins can both be used for filtering, but they have different performance characteristics. Joins often perform better for large datasets, while subqueries can be more readable for existence checks.
Complex date/time filtering involves date arithmetic functions, DATEADD/DATEDIFF, handling of fiscal periods, and consideration of business calendars. Proper indexing strategies are crucial for performance.
XML filtering uses XPath expressions, XML methods like exist(), value(), and nodes(). Consider proper indexing of XML columns and the performance impact of complex XML operations.
Multi-tenant filtering requires consistent application of tenant identifiers, proper indexing strategies, and consideration of row-level security. Use parameters or context settings to ensure tenant isolation.
Soft delete filtering typically uses flag columns or deletion timestamps. Consider impact on indexes, constraints, and query performance. May require careful handling in joins and aggregate operations.
Aggregate-based filtering uses subqueries or window functions to compute aggregates, then filters based on these results. Consider performance implications and appropriate use of HAVING vs WHERE clauses.
Versioned data filtering involves temporal tables, effective dates, or version numbers. Consider overlap handling, current version retrieval, and historical data access patterns.
Geospatial filtering uses spatial data types and functions for operations like distance calculations, containment checks, and intersection tests. Consider spatial indexes for performance optimization.
Dynamic pivot filtering involves generating SQL dynamically based on pivot columns, using CASE expressions or PIVOT operator, and handling varying numbers of columns. Consider performance and maintenance implications.
Materialized views can pre-compute complex filtering conditions for better performance. Consider refresh strategies, storage requirements, and query rewrite capabilities of the database.
Row-level security implements access control at the row level using security predicates, column masks, or policy functions. Consider performance impact, maintenance overhead, and security implications.