SQL Design Patterns: Expert Guide to SQL Programming

Vadim Tropashko

下單後立即進貨 (1週~2週)

買這商品的人也買了...

相關活動主題

20180806 35 %e9%87%91%e5%b1%ac%e6%9b%b8%e7%b1%a4small

商品描述

Description

This indispensable SQL reference book is the first-of- its-kind to leverage the benefits of design patterns to relational database SQL queries. Leveraging on the success of programming design patterns books, SQL guru Vadim Tropashko categorizes and describes all common SQL structures and design patterns.

This is an important book for programmers and managers alike. Because SQL is a declarative language there are many ways to write any SQL query and convoluted and clumsy SQL syntax has become a maintenance nightmare. Professional database programmers must understand the correct way to write SQL for complicated database queries, and managers must institute formal SQL coding standards to improve productivity and maintainability.

As relational databases structures become more complex, so do their SQL queries. Complex SQL becomes difficult to understand and maintain, especially with novices who pile-on nested subqueries, and all SQL programmer must learn rudimentary SQL theory, which classifies known SQL solutions into common patterns.

SQL design patterns greatly improve the quality and productivity of systems development projects because SQL design patterns form a "best practices" foundation for all relational database queries. The SQL programmers benefit from using SQL design patterns since all query structures are standardized with common approaches, and management benefits by having standardized and maintainable SQL syntax.

This book is both pragmatic and academic, a worthy academic book that emphasizes theoretical foundation for almost every type of SQL query problem. Most of the material has accompanying figures that help visualizing the problem.

This is not a book for casual programmers or dilettantes. It is specifically created for professional SQL developers who need to solve complex problems using common SQL idioms.


KEY FEATURES:

  • Learn the SQL best practices used by successful professionals.
  • Improve productivity and maintainability with SQL coding standards.
  • Learn relational division, set joins, user-defined aggregates, pivot, and many other advanced patterns.
  • Learn how SQL Design Patterns create common solutions.
  • See proven best practices for SQL coding styles.
  • Learn (literally!) countless ways to implement integer generators in SQL.
  • Understand how to perform complex data manipulation with SQL advanced predicates.
  • Leverage materialized views to implement ANSI SQL assertions.
  • Explore hierarchical SQL queries.


BOOK PREFACE:

SQL is a very successful language. Yet, is there a place for an advanced SQL book in the era of “Learn Technology X in 10 Minutes”? Indeed, the tech industry today emphasizes a shallow knowledge of a huge number of technical skills, rather than deep knowledge of a more specialized skill. That’s how workers have been getting jobs, by knowing a tiny bit of many skills employers might need. Someone who knows how to use SQL in an advanced way does not have a proportionate advantage in getting a job over someone who knows only the basics. If this second person, however, also knows J2EE, XSLT, Ajax, Flash, or any other flash in the pan to a similarly basic level, then he or she has a greater employment advantage.

The major flaw of this line of reason is equating the sophistication of SQL to these rather unsound technologies. This might be surprising to a newcomer who generally finds SQL a little bit old fashioned compared to the “modern” programming languages. It is almost as old as C, which spawned at least 3 newer generation languages already, and it looks like COBOL, so why isn’t it obsolete yet? Let me assure you that this appearance is misleading. Under the cover of sloppy and archaic syntax, a high abstraction language is found.

SQL programming is very unusual from the procedural perspective: there is no explicit flow control, no loops and no variables either to apply operations to or to store intermediate results into. SQL heavily leverages predicates instead, which elevates it to Logic Programming. Then, the grouping and aggregation syntax blends naturally into this already formidable logic foundation. Anybody who rediscovers that matrix or polynomial multiplication can be written in just three lines of code has a long lasting impression.

These ingredients that make SQL unique partially explain why advanced SQL programming does not revolve around syntax features, but demands a SQL programmer to develop an ability to recognize complex patterns. Yes, beyond a certain point a skill of piling up subqueries does not give much of a return and one has to study some rudimentary theory, which classifies known SQL solutions into patterns.

Patterns in procedural programming became popular a decade ago, originated with a landmark book by Gamma et. al. Each pattern has its name so that developers could quickly refer to it by just a name. “Oh, that’s a singleton!” instead of a lengthy description and often accompanied with a code snippet.

Patterns received a sour reception in a high abstraction language community. The prevailing perception was that patterns are a signature of low level programming. When a programmer sees patterns in her programs, it is a sign of trouble. The shape of a program should reflect only the problem it needs to solve. Any other regularity in the code indicates that abstractions are not powerful enough.

In reality, however, any language is quite limited in its abstraction power, declarative languages notwithstanding. Sooner or later we have to find workarounds for those limitations. This is how SQL patterns were born!

Patterns greatly improve our communication capabilities. On internet SQL forums it is not uncommon for people to ask the same question over and over again. Pattern names such as Interval coalesce or Relational division, for example, rarely surface in the discussion thread, giving way to numerous reply messages pointlessly competing to see who can find a query that does not look intimidating. Patterns allow succinct replies like this: “Lookup the Interval coalesce method in the … textbook”.

Establishing common pattern names is the first goal of this book. Most of the patterns have standard names: Skyline query, Pivot, or Nested Intervals, for example. Few do not; we have to work out a name, like the fancy sounding Discrete interval sampling, for example.

When presenting SQL patterns in this book I decided to dismiss the standard template form. Template is perfect for reference material, but is a nuisance for a textbook. More important than this stylistic comment, however, is the fact that fairly soon you might stumble into patterns that require little familiarity with undergraduate level math. Don’t be discouraged, however: as John Garmany suggested, many topics start making sense on second reading. In the Indicator Functions section, for example, you may want to skip the theory, first, rewind to the sample problem and SQL solutions, then, rollback to the theory.

List of SQL Design patterns:

  • Counting
  • Conditional summation
  • Integer generator
  • String/Collection decomposition
  • List Aggregate
  • Enumerating pairs
  • Enumerating sets
  • Interval coalesce
  • Discrete interval sampling
  • User-defined aggregate
  • Pivot
  • Symmetric difference
  • Histogram
  • Skyline query
  • Relational division
  • Outer union
  • Complex constraint
  • Nested intervals
  • Transitive closure
  • Hierarchical total

 

Table of Contents

Chapter 1 - Counting in SQL
List of patterns
Introduction to SQL Counting
Counting Ordered Rows
Conditional Summation with CASE Operator
Indicator and Step Functions
A Case for the CASE Operator
Summarizing by more than one Relation
Interval Coalesce

Chapter 2 - Integer Generators in SQL
Integers Relation
Recursive With
Big Table
Table Function
Cube
Hierarchical Query
String Decomposition
Enumerating Pairs
Enumerating Sets of Integers
Discrete Interval Sampling

Chapter 3 - Exotic Operators in SQL
Introduction to SQL exotic operators
List Aggregate
Product
Factorial
Interpolation
Pivot
Symmetric Difference
Histograms in SQL
Equal-Width Histogram
Equal-Height Histogram
Logarithmic Buckets
Skyline Query
Relational Division
Outer Union

Chapter 4 - SQL Constraints
Function Based Constraints
Symmetric Functions
Materialized View Constraints
Disjoint Sets
Disjoint Intervals
Temporal Foreign Key Constraint
Cardinality Constraint

Chapter 5 - Trees in SQL
Materialized Path
Nested Sets
Interval Halving
From Binary to N-ary Trees
Matrix Encoding
Parent and Children Query
Nested Intervals
Descendants Query
Ancestor Criteria
Ancestors Query
Converting Matrix to Path
Inserting Nodes
Relocating Tree Branches
Ordering
Exotic Labeling Schemas
Dietz Encoding
Pre-order – Depth Encoding
Reversed Nesting
Ordered Partitions

Chapter 6 - Graphs in SQL
Schema Design
Tree Constraint
Transitive Closure
Recursive SQL
Connect By
Incremental Evaluation
Hierarchical Weighted Total
Generating Baskets
Comparing Hierarchies