Docs: Docsv1 Great Expectation changes (#59)

Author: RounakDhillon

connectors/database/salesforce/index.mdx

@@ -54,8 +54,24 @@ For a complete guide on managing secrets in hybrid setups, see the [Hybrid Inges
   </Tip>
 - **Salesforce Object Name**: Specify the Salesforce Object Name in case you want to ingest a specific object.  If left blank, we will ingest all the Objects.
 - **Salesforce API Version**: Follow the steps mentioned [here](https://help.salesforce.com/s/articleView?id=000386929&type=1) to get the API version. Enter the numerical value in the field, For example `42.0`.
-- **Salesforce Domain**: When connecting to Salesforce, you can specify the domain to use for accessing the platform. The common domains include `login` and `test`, and you can also utilize Salesforce My Domain.
-By default, the domain `login` is used for accessing Salesforce.
+- **Salesforce Domain**: Specify the Salesforce domain (subdomain only) to use for authentication. This field accepts only the domain prefix, not the full URL.
+
+  **Common values:**
+  - `login` (default) - For production instances (resolves to `https://login.salesforce.com`)
+  - `test` - For sandbox instances (resolves to `https://test.salesforce.com`)
+  
+  **For Salesforce My Domain:**
+  Enter your custom domain prefix, including all subdomain components such as `.my` or `.sandbox.my`, but without `.salesforce.com`.
+  
+  **Examples:**
+  - If your My Domain URL is `https://mycompany.my.salesforce.com`, enter: `mycompany.my`
+  - If your sandbox My Domain URL is `https://mycompany--uat.sandbox.my.salesforce.com`, enter: `mycompany--uat.sandbox.my`
+  - If your URL is `https://example-dot-com--uat.sandbox.my.salesforce.com`, enter: `example-dot-com--uat.sandbox.my`
+  
+  <Note>
+  **Important:** Do NOT enter the full URL or include `.salesforce.com`. Only enter the subdomain prefix as shown in the examples above.
+  </Note>
+
 **SSL Configuration**
 In order to integrate SSL in the Metadata Ingestion Config, the user will have to add the SSL config under sslConfig which is placed in the source.
 </Step>

connectors/ingestion/great-expectations.mdx

@@ -41,6 +41,15 @@ action:
   database_name: <databaseName in OM> 
   schema_name: <schemaName in OM>
   table_name: <tableName in OM> 
+  expectation_suite_table_config_map:
+    my_first_suite_name:
+        database_name: <databaseName in OM>
+        schema_name: <schemaName in OM>
+        table_name: <tableName in OM>
+    my_other_suite_name:
+        database_name: <databaseName in OM>
+        schema_name: <schemaName in OM>
+        table_name: <tableName in OM>
 [...]
 ```
 
@@ -52,11 +61,25 @@ In your checkpoint yaml file, you will need to add the above code block in `acti
 - `class_name`: this is the name of the class that will be used to execute the custom action
 - `config_file_path`: this is the path to your `config.yaml` file that holds the configuration of your OpenMetadata server
 - `database_service_name`: [Optional] this is an optional parameter. If not specified and 2 tables have the same name in 2 different OpenMetadata services, the custom action will fail
-- `database_name`: [Optional] only required for `RuntimeDataBatchSpec` execution (e.g. run GX against a dataframe). 
-- `schema_name`: [Optional] only required for `RuntimeDataBatchSpec` execution (e.g. run GX against a dataframe). 
-- `table_name`: [Optional] only required for `RuntimeDataBatchSpec` execution (e.g. run GX against a dataframe). 
+- `database_name`: [Optional] The database name as it appears in OpenMetadata. For table-based validations (`SqlAlchemyDatasourceBatchSpec`), this is inferred from the batch spec. **Required** for query-based or dataframe validations (`RuntimeQueryBatchSpec`, `RuntimeDataBatchSpec`) where the table context must be explicitly specified.
+- `schema_name`: [Optional] The schema name as it appears in OpenMetadata. For table-based validations, this is inferred from the batch spec. **Required** for query-based or dataframe validations. Defaults to *default* if not specified.
+- `table_name`: [Optional] The table name as it appears in OpenMetadata. For table-based validations, this is inferred from the batch spec. **Required** for query-based or dataframe validations where the table cannot be automatically determined.
+- `expectation_suite_table_config_map`: [Optional] A dictionary mapping expectation suite names to their target OpenMetadata tables. Required when running multi-table checkpoints, where different expectation suites should send results to different tables. Each entry specifies the `database_name`, `schema_name` and `table_name` for routing validation results.
 
 
+<Info>
+**Multi-Table Checkpoints**
+
+When validating **multiple tables in a single checkpoint**, use the `expectation_suite_table_config_map` parameter to route validation results to the correct OpenMetadata tables. This is necessary because:
+- Each expectation suite may target a different table
+- The checkpoint action needs to know where to send each suite's results
+- Without the mapping, all results would attempt to go to the same default table
+
+**Example scenario:** You have a checkpoint validating both `users` and `orders` tables with separate expectation suites (`users_suite` and `orders_suite`). The `expectation_suite_table_config_map` ensures `users_suite` results go to the `users` table and the `orders_suite` go to the `orders` table.
+
+For single-table checkpoints, this parameter is not needed - the table information is provided directly or inferred from the batch spec.
+</Info>
+
 **Note**
 
 If you are using Great Expectation `DataContext` instance in Python to run your tests, you can use the `run_checkpoint` method as follows:
@@ -174,6 +197,96 @@ context.add_or_update_checkpoint(checkpoint=checkpoint)
 checkpoint_result = checkpoint.run()
 ```
 
+#### Multi-Table Checkpoint Example
+
+Validate multiple tables in a single checkpoint run:
+
+```python
+import great_expectations as gx
+from great_expectations.checkpoint import Checkpoint
+
+context = gx.get_context()
+conn_string = "postgresql+psycopg2://user:pw@host:port/db"
+
+data_source = context.sources.add_postgres(
+  name="my_datasource",
+  connection_string=conn_string,
+)
+
+# Set up users table validation
+users_asset = data_source.add_table_asset(
+  name="users_asset",
+  table_name="users",
+  schema_name="public",
+)
+users_suite = "users_suite"
+context.add_or_update_expectation_suite(expectation_suite_name=users_suite)
+users_validator = context.get_validator(
+  batch_request=users_asset.build_batch_request(),
+  expectation_suite_name=users_suite,
+)
+users_validator.expect_column_values_to_not_be_null(column="email")
+users_validator.save_expectation_suite(discard_failed_expectations=False)
+
+# Set up orders table validation
+orders_asset = data_source.add_table_asset(
+  name="orders_asset",
+  table_name="orders",
+  schema_name="public",
+)
+orders_suite = "orders_suite"
+context.add_or_update_expectation_suite(expectation_suite_name=orders_suite)
+orders_validator = context.get_validator(
+  batch_request=orders_asset.build_batch_request(),
+  expectation_suite_name=orders_suite,
+)
+orders_validator.expect_column_values_to_be_between(column="amount", min_value=0, max_value=1000000)
+orders_validator.save_expectation_suite(discard_failed_expectations=False)
+
+# Create multi-table checkpoint
+checkpoint = Checkpoint(
+  name="multi_table_checkpoint",
+  run_name_template="%Y%m%d-%H%M%S-multi-table",
+  data_context=context,
+  validations=[
+      {
+          "batch_request": users_asset.build_batch_request(),
+          "expectation_suite_name": users_suite,
+      },
+      {
+          "batch_request": orders_asset.build_batch_request(),
+          "expectation_suite_name": orders_suite,
+      },
+  ],
+  action_list=[
+      {
+          "name": "openmetadata_action",
+          "action": {
+              "module_name": "metadata.great_expectations.action",
+              "class_name": "OpenMetadataValidationAction",
+              "config_file_path": "/path/to/config/",
+              "database_service_name": "my_postgres_service",
+              "expectation_suite_table_config_map": {
+                  "users_suite": {
+                      "database_name": "production",
+                      "schema_name": "public",
+                      "table_name": "users",
+                  },
+                  "orders_suite": {
+                      "database_name": "production",
+                      "schema_name": "public",
+                      "table_name": "orders",
+                  },
+              },
+          }
+      },
+  ],
+)
+
+context.add_or_update_checkpoint(checkpoint=checkpoint)
+checkpoint_result = checkpoint.run()
+```
+
 ### Working with GX 1.x.x?
 In v1.x.x GX introduced significant changes to their SDK. One notable change was the removal of the `great_expectations` CLI. OpenMetadata introduced support for 1.x.x version through its `OpenMetadataValidationAction1xx` class. You will need to first `pip install 'open-metadata[great-expectations-1xx]'. Below is a complete example