@@ -230,6 +230,7 @@ These deliberately are not:
 | `accessible_tables` | `SQL_ACCESSIBLE_TABLES` |
 | `data_source_read_only` | `SQL_DATA_SOURCE_READ_ONLY` |
 | `search_pattern_escape` | `SQL_SEARCH_PATTERN_ESCAPE` |
+| `keywords` | the data source's own reserved words, *before* ODBC's are subtracted (`SQL_KEYWORDS`) |
 
 Each states a **capability**, where any default is a claim the backend author
 never made. `0` understates ("this data source cannot do this at all") and
@@ -259,6 +260,12 @@ Two corollaries worth checking when adding an info type:
   `info_type_default_response` gives an unhandled `String`-shaped info type
   `""`, which is the right *shape* but is not in any Y/N value list. Such a
   type needs either a shared `"N"` arm in `default_get_info` or a hook.
+- **An empty *list* is an answer too.** `SQL_KEYWORDS` reads as an empty
+  string just like an unhandled `String`-shaped type, but it means "this data
+  source reserves nothing beyond ODBC" — which applications act on when
+  deciding what to quote. It is a `Backend::keywords` hook for that reason;
+  core owns only the spec's subtraction of `ODBC_RESERVED_KEYWORDS`, which is
+  the same for every backend.
 - **Watch for info types that constrain each other.** `SQL_SQL_CONFORMANCE`
   fixes the value of `SQL_GROUP_BY`, `SQL_CORRELATION_NAME`,
   `SQL_NON_NULLABLE_COLUMNS`, `SQL_CONCAT_NULL_BEHAVIOR`, `SQL_SUBQUERIES`
 
@@ -70,6 +70,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   `set_prepared_statement` and `discard_result_set` helpers that maintain it.
   `StatementHandle::statement` no longer doubles as the answer to "is a cursor
   open?" — see the `Fixed` entry below.
+- `types::ODBC_RESERVED_KEYWORDS`, the reserved-word list from Appendix C of
+  the ODBC specification. `SQL_KEYWORDS` is defined as the data source's own
+  keywords *excluding* these, so the list and the subtraction now live in core
+  once instead of being transcribed into each driver.
 
 ### Changed
 
@@ -108,13 +112,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   `timedate_add_intervals`, `timedate_diff_intervals`, `subqueries`,
   `column_alias`, `concat_null_behavior`, `union_support`,
   `convert_functions`, `order_by_columns_in_select`, `accessible_tables`,
-  `data_source_read_only` and `search_pattern_escape`.
+  `data_source_read_only`, `search_pattern_escape` and `keywords`.
   They are required rather than defaulted on purpose:
   each states a *capability*, where a defaulted value is a claim the backend
   author never made and is unlikely to notice. A defaulted `0` understates and
   a defaulted `true` overstates; the compiler asking is what makes the fact
   explicit. Every one of them replaces a value core previously invented (see
   `Fixed`).
+- **Breaking:** `SQL_KEYWORDS` (89) now comes from the new required
+  `Backend::keywords`, filtered against `ODBC_RESERVED_KEYWORDS`, sorted and
+  comma-separated. **Every backend must implement it** — there is no default,
+  because an empty list is the claim that the data source reserves nothing
+  beyond ODBC. A backend returns its raw reserved words in any order and any
+  case; core applies the spec's subtraction. It does so on every call rather
+  than caching (a `static` cannot be generic over the backend); a backend whose
+  list is expensive to produce should cache on its own side. Returning `&[]`
+  reproduces the value core previously gave everyone.
 - `SQL_ALTER_TABLE` and `SQL_OJ_CAPABILITIES` now come from
   `Backend::alter_table_support` / `Backend::outer_join_capabilities` instead
   of defaulting to `0`. `0` remains the shared default for the surrounding
@@ -142,7 +155,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   `SQL_ROW_UPDATES` (11) `"N"`, `SQL_PROCEDURES` (21) `"N"`,
   `SQL_MULTIPLE_ACTIVE_TXN` (37) `"N"`, `SQL_DATABASE_NAME` (16) `""`,
   `SQL_PROCEDURE_TERM` (40) `""` (consistent with `SQL_PROCEDURES = "N"`),
-  `SQL_TABLE_TERM` (45) `"table"`, and `SQL_KEYWORDS` (89) `""`.
+  `SQL_TABLE_TERM` (45) `"table"`, and `SQL_KEYWORDS` (89) — the last of these
+  now carrying the backend's own list rather than `""`, see below.
   All come from `common_get_info_raw`, and core's own fallback consults that
   helper, so a backend whose `get_info_raw` does not delegate to it gets the
   same answer. That last change also fixes `SQL_QUOTED_IDENTIFIER_CASE` for
@@ -187,6 +201,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `SQL_SEARCH_PATTERN_ESCAPE` comes from the backend. It describes what
   escapes `%` and `_` in catalog-function pattern arguments, which the backend
   interprets.
+- `SQL_KEYWORDS` is stated by the backend. Core answered it with `""` for
+  everyone, which is not an absence of an answer but the claim that the data
+  source reserves nothing beyond ODBC — and applications read it to decide
+  which identifiers need quoting, so a wrong empty list is how a generated
+  identifier goes unquoted and the statement fails to parse. Every real
+  backend has keywords of its own.
 - `SQL_EXPRESSIONS_IN_ORDERBY` is stated by the backend. It previously fell to
   `""`, which reads as "no" to a tool deciding whether to push an expression
   into `ORDER BY`.
 
@@ -553,6 +553,27 @@ pub trait Backend: Sized + Send + Sync + 'static {
     /// cannot distinguish from a backend that simply never set it.
     fn search_pattern_escape() -> &'static str;
 
+    /// The data source's own reserved words, unfiltered.
+    ///
+    /// Core reports `SQL_KEYWORDS` (89) from this, after removing everything
+    /// ODBC already reserves — the spec defines the info type as the data
+    /// source's keywords *excluding* its own ("This list does not contain
+    /// keywords specific to ODBC or keywords used by both the data source and
+    /// ODBC"), so a backend states the raw fact and core applies the rule once
+    /// against [`ODBC_RESERVED_KEYWORDS`](crate::types::ODBC_RESERVED_KEYWORDS).
+    ///
+    /// Required, not defaulted: an empty list is the claim that this data
+    /// source reserves nothing beyond ODBC, which applications act on when
+    /// deciding what to quote.
+    ///
+    /// Return the raw names in any order and in any case; core filters
+    /// case-insensitively, sorts, and joins. Note that it does so on **every**
+    /// call rather than caching: a `static` cannot be generic over `B`, and
+    /// `SQLGetInfo(SQL_KEYWORDS)` is not a hot path. A backend whose list is
+    /// expensive to produce — read out of a linked library, say — should cache
+    /// behind its own `OnceLock` and return the cached slice from here.
+    fn keywords() -> &'static [&'static str];
+
     /// The `SQL_TIMEDATE_ADD_INTERVALS` (109) bitmask: the interval units the
     /// `TIMESTAMPADD` scalar function accepts, as an OR of the
     /// [`SQL_FN_TSI_*`](crate::types::SQL_FN_TSI_SECOND) constants.
@@ -915,6 +936,36 @@ pub fn default_get_info<B: Backend>(
 /// Generic over the calling backend so that `SQL_CURSOR_ROLLBACK_BEHAVIOR` can be
 /// derived from [`Backend::cursor_rollback_behavior`] -- call it as
 /// `common_get_info_raw::<Self>(info_type)`.
+/// The `SQL_KEYWORDS` (89) value for `B`: [`Backend::keywords`] minus
+/// everything ODBC itself reserves, sorted, comma-separated with no spaces.
+///
+/// The subtraction is what the spec defines the info type to be — "This list
+/// does not contain keywords specific to ODBC or keywords used by both the
+/// data source and ODBC" — so it lives here once rather than in every backend.
+/// Comparison is ASCII-case-insensitive: the reserved list is upper-case and a
+/// data source that spells its keywords in lower case still shares them.
+///
+/// Sorting is not required by the spec, but makes the value stable for
+/// anything that diffs or caches it, whatever order the backend enumerates in.
+///
+/// Recomputed on every call. A `static` cache cannot be generic over `B`, and
+/// this is a linear scan of a short list against a fixed one on a path
+/// `SQLGetInfo` reaches at most a handful of times per connection; a backend
+/// with an expensive list caches on its own side (see [`Backend::keywords`]).
+fn data_source_specific_keywords<B: Backend>() -> String {
+    let mut names: Vec<&'static str> = B::keywords()
+        .iter()
+        .copied()
+        .filter(|name| {
+            !crate::types::ODBC_RESERVED_KEYWORDS
+                .iter()
+                .any(|reserved| reserved.eq_ignore_ascii_case(name))
+        })
+        .collect();
+    names.sort_unstable();
+    names.join(",")
+}
+
 pub fn common_get_info_raw<B: Backend>(info_type: u16) -> Option<InfoValue> {
     use crate::types::{
         InfoValue, SQL_CURSOR_ROLLBACK_BEHAVIOR, SQL_DATABASE_NAME, SQL_FILE_USAGE,
@@ -942,15 +993,19 @@ pub fn common_get_info_raw<B: Backend>(info_type: u16) -> Option<InfoValue> {
         // Core opens no transaction of its own, so it certainly cannot hold
         // two open at once. A backend that can answers before delegating.
         SQL_MULTIPLE_ACTIVE_TXN => Some(InfoValue::String("N".into())),
+        // The data source's own reserved words, minus everything ODBC already
+        // reserves -- the subtraction the spec defines for this info type,
+        // applied once here rather than in each backend. The list itself is a
+        // capability, so it comes from `Backend::keywords`; core only owns the
+        // rule.
+        SQL_KEYWORDS => Some(InfoValue::String(data_source_specific_keywords::<B>())),
         // The remaining character-string info types with no
-        // `odbc_sys::InfoType` variant. Empty is a valid value for all but
-        // SQL_TABLE_TERM: there is no shared name for the current database,
-        // no shared list of data-source-specific reserved words, and -- given
+        // `odbc_sys::InfoType` variant. Empty is a valid value for both:
+        // there is no shared name for the current database, and -- given
         // SQL_PROCEDURES above answers "N" -- no procedures to have a vendor
-        // term for. Every data source has tables, so that one gets the
+        // term for. Every data source has tables, so SQL_TABLE_TERM gets the
         // generic term rather than "".
         SQL_DATABASE_NAME => Some(InfoValue::String(String::new())),
-        SQL_KEYWORDS => Some(InfoValue::String(String::new())),
         SQL_PROCEDURE_TERM => Some(InfoValue::String(String::new())),
         SQL_TABLE_TERM => Some(InfoValue::String("table".into())),
         _ => None,
@@ -1627,6 +1682,7 @@ mod tests {
             accessible_tables,
             data_source_read_only,
             search_pattern_escape,
+            keywords,
             cursor_commit_behavior,
             cursor_rollback_behavior,
         );
 
@@ -1163,9 +1163,12 @@ mod tests {
         // Every data source has tables, so unlike the catalog and schema terms
         // this one has no "empty if unsupported" case.
         (crate::types::SQL_TABLE_TERM,          "table",     "SQL_TABLE_TERM"),
-        // A comma-separated list of data-source-specific reserved words; empty
-        // is a valid list and the only honest shared answer.
-        (crate::types::SQL_KEYWORDS,            "",          "SQL_KEYWORDS"),
+        // A comma-separated list of data-source-specific reserved words,
+        // derived from `MockBackend::keywords` with ODBC's own subtracted out
+        // (`SELECT` is dropped) and the remainder sorted. Asserted here rather
+        // than only in `backend.rs` so the value is proven to survive the
+        // string-shaped `sql_get_info_w` path, not just the raw dispatch.
+        (crate::types::SQL_KEYWORDS,            "MOCK_ATTACH,MOCK_PRAGMA", "SQL_KEYWORDS"),
         (crate::types::SQL_DATABASE_NAME,       "",          "SQL_DATABASE_NAME"),
     ];
 
@@ -1231,4 +1234,96 @@ mod tests {
             cleanup(env, conn, stmt);
         }
     }
+
+    /// Runs `SQLGetInfoW(SQL_KEYWORDS)` against `B` through the whole FFI path
+    /// — allocate, connect, query, disconnect, free — and returns the text it
+    /// wrote. Generic, unlike the shared helpers above, because the point of
+    /// these assertions is that the answer moves with the backend.
+    unsafe fn sql_keywords_of<B: Backend>() -> String {
+        unsafe {
+            let mut env: *mut c_void = std::ptr::null_mut();
+            let _ = sql_alloc_handle::<B>(HandleType::Env as i16, std::ptr::null_mut(), &mut env);
+            let mut conn: *mut c_void = std::ptr::null_mut();
+            let _ = sql_alloc_handle::<B>(HandleType::Dbc as i16, env, &mut conn);
+
+            let wide: Vec<u16> = "Host=localhost;Database=test".encode_utf16().collect();
+            assert_eq!(
+                crate::ffi::connect::sql_driver_connect_w::<B>(
+                    conn,
+                    std::ptr::null_mut(),
+                    wide.as_ptr(),
+                    wide.len() as i16,
+                    std::ptr::null_mut(),
+                    0,
+                    std::ptr::null_mut(),
+                    0,
+                ),
+                SqlReturn::SUCCESS,
+            );
+
+            // Sentinel-filled, so an empty answer is distinguishable from a
+            // `U32(0)` one that merely looks empty.
+            let mut buf = [0xEEu16; 64];
+            let mut str_len: i16 = -1;
+            let ret = sql_get_info_w::<B>(
+                conn,
+                crate::types::SQL_KEYWORDS,
+                buf.as_mut_ptr() as *mut c_void,
+                (buf.len() * 2) as i16,
+                &mut str_len,
+            );
+            assert_eq!(ret, SqlReturn::SUCCESS, "SQL_KEYWORDS must not error");
+            assert!(
+                str_len >= 0 && str_len % 2 == 0,
+                "SQL_KEYWORDS is a character string, so StringLength is an even \
+                 byte count; got {str_len}"
+            );
+            let units = str_len as usize / 2;
+            let value = String::from_utf16_lossy(&buf[..units]);
+            assert_eq!(buf[units], 0, "SQL_KEYWORDS must be null-terminated");
+
+            let _ = crate::ffi::connect::sql_disconnect::<B>(conn);
+            let _ = sql_free_handle::<B>(HandleType::Dbc as i16, conn);
+            let _ = sql_free_handle::<B>(HandleType::Env as i16, env);
+            value
+        }
+    }
+
+    /// `SQL_KEYWORDS` is the spec's *subtraction*: the data source's reserved
+    /// words minus the ones ODBC already reserves. Core owns that rule and
+    /// `Backend::keywords` owns the raw list, so what an application sees has
+    /// to move with the backend — the empty string core used to return for
+    /// everyone is the claim "this data source reserves nothing beyond ODBC",
+    /// which is how a generated identifier ends up unquoted.
+    ///
+    /// Asserted through `sql_get_info_w` rather than `common_get_info_raw`, so
+    /// the dispatch ordering is covered too.
+    #[test]
+    fn sql_keywords_is_the_backend_list_minus_odbcs_own() {
+        use crate::test_utils::{
+            MockAltBackend, MockNoKeywordsBackend, MockOverlappingKeywordsBackend,
+            MockReservedOnlyKeywordsBackend,
+        };
+
+        unsafe {
+            // Nothing to subtract from: the same value core produced before the
+            // hook existed, so the shape is unchanged for a data source that
+            // genuinely reserves nothing extra.
+            assert_eq!(sql_keywords_of::<MockNoKeywordsBackend>(), "");
+            // `SELECT` is ODBC's; `UNNEST` is not.
+            assert_eq!(
+                sql_keywords_of::<MockOverlappingKeywordsBackend>(),
+                "UNNEST"
+            );
+            // Case-insensitive, so a lower-case list of ODBC's own words leaves
+            // nothing behind.
+            assert_eq!(sql_keywords_of::<MockReservedOnlyKeywordsBackend>(), "");
+            // Sorted and comma-separated with no spaces, whatever order the
+            // backend enumerates in — `MockBackend` declares
+            // `["MOCK_PRAGMA", "SELECT", "MOCK_ATTACH"]`.
+            assert_eq!(sql_keywords_of::<MockBackend>(), "MOCK_ATTACH,MOCK_PRAGMA");
+            // And it moves with the backend.
+            assert_eq!(sql_keywords_of::<MockAltBackend>(), "ALT_VACUUM");
+        }
+    }
 }