@neralabs/rerail-pack-sql 0.1.2 → 0.1.4

package/rules/sqlfluff-am01-ambiguous-distinct.json

@@ -0,0 +1,53 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "sqlfluff-am01-ambiguous-distinct",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Avoid DISTINCT in a SQL SELECT that already has GROUP BY; the grouping already makes the rows unique.",
+  "scope": {
+    "include": [
+      "**/*.sql"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "distinct-with-group-by",
+      "forbid": {
+        "ast": {
+          "language": "sql",
+          "rule": {
+            "kind": "keyword_distinct",
+            "inside": {
+              "kind": "select",
+              "stopBy": "neighbor",
+              "precedes": {
+                "kind": "from",
+                "has": {
+                  "kind": "group_by"
+                }
+              }
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.start",
+        "code": "AM01",
+        "message": "Remove DISTINCT from this SELECT; its GROUP BY already makes the rows unique.",
+        "suppress": {
+          "sqlfluff": {
+            "rules": [
+              "AM01",
+              "L021",
+              "all",
+              "ambiguous",
+              "ambiguous.distinct",
+              "core"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

package/rules/sqlfluff-am05-ambiguous-join.json

@@ -0,0 +1 @@
+{"format":"rerail.policy/v1","id":"sqlfluff-am05-ambiguous-join","revision":1,"mode":"steer","description":"Write INNER JOIN instead of a bare JOIN in SQL so the join type is explicit.","scope":{"include":["**/*.sql"],"exclude":[]},"clauses":[{"id":"bare-join","forbid":{"ast":{"language":"sql","rule":{"any":[{"kind":"join"},{"kind":"lateral_join"}],"regex":"(?i)^join\\b"}}},"violation":{"anchor":"witness.start","code":"AM05","message":"Write this join as INNER JOIN so its type is explicit.", "suppress": { "sqlfluff": { "rules": ["AM05", "L051", "all", "ambiguous", "ambiguous.join"] } }}}]}

package/rules/sqlfluff-am09-ambiguous-order-by-limit.json

@@ -0,0 +1,110 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "sqlfluff-am09-ambiguous-order-by-limit",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Add ORDER BY to any SQL query that uses LIMIT or OFFSET; without it, which rows come back is not deterministic.",
+  "scope": {
+    "include": [
+      "**/*.sql"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "limit-without-order-by",
+      "forbid": {
+        "ast": {
+          "language": "sql",
+          "rule": {
+            "kind": "limit",
+            "not": {
+              "any": [
+                {
+                  "follows": {
+                    "kind": "order_by",
+                    "stopBy": "end"
+                  }
+                },
+                {
+                  "inside": {
+                    "kind": "from",
+                    "stopBy": "neighbor",
+                    "inside": {
+                      "kind": "set_operation",
+                      "stopBy": "neighbor"
+                    },
+                    "not": {
+                      "precedes": {
+                        "regex": "(?s)."
+                      }
+                    }
+                  }
+                }
+              ]
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.start",
+        "code": "AM09",
+        "message": "LIMIT and OFFSET are used without ORDER BY, which may lead to non-deterministic results.",
+        "suppress": {
+          "sqlfluff": {
+            "rules": [
+              "AM09",
+              "all",
+              "ambiguous",
+              "ambiguous.order_by_limit"
+            ]
+          }
+        }
+      }
+    },
+    {
+      "id": "offset-without-limit-or-order-by",
+      "forbid": {
+        "ast": {
+          "language": "sql",
+          "rule": {
+            "kind": "select",
+            "has": {
+              "all": [
+                {
+                  "pattern": "$OFFSET",
+                  "kind": "offset"
+                },
+                {
+                  "not": {
+                    "kind": "limit"
+                  }
+                },
+                {
+                  "not": {
+                    "kind": "order_by"
+                  }
+                }
+              ]
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "capture.OFFSET",
+        "code": "AM09",
+        "message": "LIMIT and OFFSET are used without ORDER BY, which may lead to non-deterministic results.",
+        "suppress": {
+          "sqlfluff": {
+            "rules": [
+              "AM09",
+              "all",
+              "ambiguous",
+              "ambiguous.order_by_limit"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

package/rules/sqlfluff-cv02-convention-coalesce.json

@@ -0,0 +1 @@
+{"format":"rerail.policy/v1","id":"sqlfluff-cv02-convention-coalesce","revision":1,"mode":"steer","description":"Use COALESCE instead of IFNULL or NVL in SQL; it is standard and works across databases.","scope":{"include":["**/*.sql"],"exclude":[]},"clauses":[{"id":"prefer-coalesce","forbid":{"ast":{"language":"sql","rule":{"kind":"invocation","has":{"kind":"object_reference","has":{"kind":"identifier","regex":"(?i)^(ifnull|nvl)$"}},"not":{"has":{"kind":"object_reference","regex":"\\."}}}}},"violation":{"anchor":"witness.start","code":"CV02","message":"Use COALESCE instead of IFNULL or NVL.", "suppress": { "sqlfluff": { "rules": ["CV02", "L060", "all", "convention", "convention.coalesce"] } }}}]}

package/rules/sqlfluff-cv04-convention-count-rows.json

@@ -0,0 +1,52 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "sqlfluff-cv04-convention-count-rows",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Use COUNT(*) instead of COUNT(1) or COUNT(0) to count rows in SQL; it states the intent directly.",
+  "scope": {
+    "include": [
+      "**/*.sql"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "count-literal",
+      "forbid": {
+        "ast": {
+          "language": "sql",
+          "rule": {
+            "kind": "invocation",
+            "regex": "^(?i:count)\\s*\\(\\s*[01]\\s*\\)$",
+            "has": {
+              "field": "parameter",
+              "kind": "term",
+              "has": {
+                "field": "value",
+                "kind": "literal"
+              }
+            }
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.start",
+        "code": "CV04",
+        "message": "Use COUNT(*) to count rows.",
+        "suppress": {
+          "sqlfluff": {
+            "rules": [
+              "CV04",
+              "L047",
+              "all",
+              "convention",
+              "convention.count_rows",
+              "core"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

package/rules/sqlfluff-cv05-convention-is-null.json

@@ -0,0 +1,61 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "sqlfluff-cv05-convention-is-null",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Use IS NULL or IS NOT NULL instead of comparing to NULL with =, != or <>; such a comparison is never true.",
+  "scope": {
+    "include": [
+      "**/*.sql"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "relational-null-comparison",
+      "forbid": {
+        "ast": {
+          "language": "sql",
+          "rule": {
+            "kind": "binary_expression",
+            "all": [
+              {
+                "has": {
+                  "field": "operator",
+                  "regex": "^(?:=|!=|<>)$",
+                  "pattern": "$$OP"
+                }
+              },
+              {
+                "has": {
+                  "field": "right",
+                  "kind": "literal",
+                  "has": {
+                    "kind": "keyword_null"
+                  }
+                }
+              }
+            ]
+          }
+        }
+      },
+      "violation": {
+        "anchor": "capture.OP",
+        "code": "CV05",
+        "message": "Comparisons with NULL should use IS or IS NOT.",
+        "suppress": {
+          "sqlfluff": {
+            "rules": [
+              "CV05",
+              "L049",
+              "all",
+              "convention",
+              "convention.is_null",
+              "core"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

package/rules/sqlfluff-cv08-convention-left-join.json

@@ -0,0 +1,18 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "sqlfluff-cv08-convention-left-join",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Use LEFT JOIN instead of RIGHT JOIN in SQL, swapping the table order; joins that all read left to right are easier to follow.",
+  "scope": {"include": ["**/*.sql"], "exclude": []},
+  "clauses": [
+    {
+      "id": "right-join",
+      "forbid": {"ast": {"language": "sql", "rule": {
+        "kind": "join",
+        "has": {"stopBy": "neighbor", "kind": "keyword_right"}
+      }}},
+      "violation": {"anchor": "witness.start", "code": "CV08", "message": "Use LEFT JOIN instead of RIGHT JOIN.", "suppress": { "sqlfluff": { "rules": ["CV08", "L055", "all", "convention", "convention.left_join"] } }}
+    }
+  ]
+}

package/rules/sqlfluff-pg01-postgres-excessive-locks.json

@@ -0,0 +1,234 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "sqlfluff-pg01-postgres-excessive-locks",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Use CONCURRENTLY on non-unique CREATE INDEX, DROP INDEX, REINDEX and REFRESH MATERIALIZED VIEW in PostgreSQL; otherwise the table is locked while it runs.",
+  "scope": {
+    "include": [
+      "**/*.sql"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "create-index-without-concurrently",
+      "forbid": {
+        "ast": {
+          "language": "sql",
+          "rule": {
+            "kind": "create_index",
+            "all": [
+              {
+                "not": {
+                  "has": {
+                    "kind": "keyword_concurrently"
+                  }
+                }
+              },
+              {
+                "not": {
+                  "has": {
+                    "kind": "keyword_unique"
+                  }
+                }
+              },
+              {
+                "not": {
+                  "inside": {
+                    "stopBy": "end",
+                    "any": [
+                      {
+                        "kind": "function_body"
+                      },
+                      {
+                        "kind": "block"
+                      },
+                      {
+                        "kind": "ERROR"
+                      }
+                    ]
+                  }
+                }
+              }
+            ]
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.start",
+        "code": "PG01",
+        "message": "CREATE INDEX should use CONCURRENTLY to avoid locking the table during the build.",
+        "suppress": {
+          "sqlfluff": {
+            "rules": [
+              "PG01",
+              "all",
+              "postgres",
+              "postgres.excessive_locks"
+            ]
+          }
+        }
+      }
+    },
+    {
+      "id": "drop-index-without-concurrently",
+      "forbid": {
+        "ast": {
+          "language": "sql",
+          "rule": {
+            "kind": "drop_index",
+            "all": [
+              {
+                "not": {
+                  "has": {
+                    "kind": "keyword_concurrently"
+                  }
+                }
+              },
+              {
+                "not": {
+                  "inside": {
+                    "stopBy": "end",
+                    "any": [
+                      {
+                        "kind": "function_body"
+                      },
+                      {
+                        "kind": "block"
+                      },
+                      {
+                        "kind": "ERROR"
+                      }
+                    ]
+                  }
+                }
+              }
+            ]
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.start",
+        "code": "PG01",
+        "message": "DROP statement should use CONCURRENTLY to avoid locking the table.",
+        "suppress": {
+          "sqlfluff": {
+            "rules": [
+              "PG01",
+              "all",
+              "postgres",
+              "postgres.excessive_locks"
+            ]
+          }
+        }
+      }
+    },
+    {
+      "id": "reindex-without-concurrently",
+      "forbid": {
+        "ast": {
+          "language": "sql",
+          "rule": {
+            "kind": "reindex_statement",
+            "all": [
+              {
+                "not": {
+                  "has": {
+                    "kind": "keyword_concurrently"
+                  }
+                }
+              },
+              {
+                "not": {
+                  "inside": {
+                    "stopBy": "end",
+                    "any": [
+                      {
+                        "kind": "function_body"
+                      },
+                      {
+                        "kind": "block"
+                      },
+                      {
+                        "kind": "ERROR"
+                      }
+                    ]
+                  }
+                }
+              }
+            ]
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.start",
+        "code": "PG01",
+        "message": "REINDEX statement should use CONCURRENTLY to avoid locking the table.",
+        "suppress": {
+          "sqlfluff": {
+            "rules": [
+              "PG01",
+              "all",
+              "postgres",
+              "postgres.excessive_locks"
+            ]
+          }
+        }
+      }
+    },
+    {
+      "id": "refresh-without-concurrently",
+      "forbid": {
+        "ast": {
+          "language": "sql",
+          "rule": {
+            "kind": "refresh_statement",
+            "all": [
+              {
+                "not": {
+                  "has": {
+                    "kind": "keyword_concurrently"
+                  }
+                }
+              },
+              {
+                "not": {
+                  "inside": {
+                    "stopBy": "end",
+                    "any": [
+                      {
+                        "kind": "function_body"
+                      },
+                      {
+                        "kind": "block"
+                      },
+                      {
+                        "kind": "ERROR"
+                      }
+                    ]
+                  }
+                }
+              }
+            ]
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.start",
+        "code": "PG01",
+        "message": "REFRESH statement should use CONCURRENTLY to avoid locking the table.",
+        "suppress": {
+          "sqlfluff": {
+            "rules": [
+              "PG01",
+              "all",
+              "postgres",
+              "postgres.excessive_locks"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

package/rules/sqlfluff-pg02-postgres-not-valid-foreign-key.json

@@ -0,0 +1,75 @@
+{
+  "format": "rerail.policy/v1",
+  "id": "sqlfluff-pg02-postgres-not-valid-foreign-key",
+  "revision": 1,
+  "mode": "steer",
+  "description": "Add PostgreSQL foreign keys with NOT VALID and validate them in a separate step; checking existing rows at once locks the table.",
+  "scope": {
+    "include": [
+      "**/*.sql"
+    ],
+    "exclude": []
+  },
+  "clauses": [
+    {
+      "id": "foreign-key-without-not-valid",
+      "forbid": {
+        "ast": {
+          "language": "sql",
+          "rule": {
+            "kind": "alter_table",
+            "has": {
+              "kind": "add_constraint",
+              "has": {
+                "kind": "constraint",
+                "has": {
+                  "kind": "keyword_foreign"
+                }
+              },
+              "not": {
+                "has": {
+                  "kind": "keyword_valid"
+                }
+              }
+            },
+            "all": [
+              {
+                "not": {
+                  "inside": {
+                    "stopBy": "end",
+                    "any": [
+                      {
+                        "kind": "function_body"
+                      },
+                      {
+                        "kind": "block"
+                      },
+                      {
+                        "kind": "ERROR"
+                      }
+                    ]
+                  }
+                }
+              }
+            ]
+          }
+        }
+      },
+      "violation": {
+        "anchor": "witness.start",
+        "code": "PG02",
+        "message": "Add this foreign key with NOT VALID and run VALIDATE CONSTRAINT as a separate step, so the table isn't locked.",
+        "suppress": {
+          "sqlfluff": {
+            "rules": [
+              "PG02",
+              "all",
+              "postgres",
+              "postgres.not_valid_foreign_key"
+            ]
+          }
+        }
+      }
+    }
+  ]
+}