README
¶
Application Audit Module
Application orchestration for parsing and, later, evaluating SQL audit requests.
Files
| File | Responsibility |
|---|---|
| parse.go | Builds application-owned parsed statements from infrastructure-backed parser adapters |
| parse_test.go | Verifies that application parsing hides parser-specific AST details |
| extract.go | Converts parsed statements into first-pass domain Statement values with explicit DDL operations, separate DDL constraint handling, typed index metadata, create-table shape flags, preserved unnamed-index names for identifier governance, explicit column charset/collation facts, normalized row-format and auto-increment-init table options, richer alter-table column/index/rename/option payloads, object-lifecycle extraction for create-view/drop/truncate, honest statement-local alter change facts, multi-column add normalization, and DML operation plus target-table facts for offline governance |
| extract_test.go | Verifies representative DDL and DML extraction behavior, including create-like/create-as/partition flags plus enriched create-table facts, preserved backticked-keyword and unnamed-index names, extracted column charset/collation facts, normalized row-format and auto-increment-init options, explicit DDL lifecycle operations, richer alter-table detail including explicit statement-local change facts, multi-column add expansion, non-index constraint handling, and extracted DML target tables |
| evaluate.go | Applies registered rules, enriches findings with explanation metadata, and aggregates statement/global findings into report output |
| evaluate_test.go | Verifies application-owned report-flow integration and explanation enrichment over the rule registry |
| explain.go | Joins evaluated findings with shipped catalog metadata and statement metadata availability notes |
| service.go | Orchestrates the full audit flow across policy loading, parsing, extraction, top-level request metadata plumbing, optional metadata enrichment, rule registration, and evaluation |
| service_test.go | Verifies the end-to-end application audit use case with defaults, config overrides, multi-statement SQL, and metadata enrichment behavior, including schema-only context and top-level request plumbing |
| metadata.go | Defines the optional metadata-provider interface and attaches schema, instance, and target-table facts to statements before evaluation |
Exports
Parse(sql string, dialect spec.Dialect)Extract(parsed ParsedSQL)EvaluateStatements(registry, statements)AuditSQL(ctx, request)RequestMetadataRequestMetadataProviderServiceNewService()Service.Audit(ctx, request)ParsedStatementParsedSQL
Dependencies
- Upstream: future CLI and public audit entrypoints
- Downstream:
context,internal/application/policy,internal/domain/report,internal/domain/rule,internal/domain/rule/ddl,internal/domain/rule/dml,internal/domain/spec,internal/infrastructure/parser/tidb,github.com/pingcap/tidb/pkg/parser/ast
Update Rule
- If members/interfaces/dependencies change, update this file in same change.
Documentation
¶
Overview ¶
Package audit orchestrates audit use cases at the application layer. input: extracted domain statements and the registered rule engine output: aggregated report results with statement and global findings pos: application evaluation step between extraction and reporting note: if this file changes, update this header and module README.md.
Package audit enriches evaluated findings with shared explanation metadata. input: rule findings, shipped catalog entries, and optional statement metadata context output: additive per-finding explanation data without changing verdict semantics pos: application explanation enrichment between evaluation and report aggregation note: if this file changes, update this header and module README.md.
Package audit orchestrates audit use cases at the application layer. input: application-owned parsed SQL statements and hidden TiDB AST nodes output: first-pass StatementSpec values plus honest statement-local alter change facts for later rule evaluation pos: application extraction step between parsing and rule execution note: if this file changes, update this header and module README.md.
Package audit orchestrates audit use cases at the application layer. input: optional metadata providers plus parsed statement targets for enrichment output: metadata-enriched statements for rules that can use live instance or schema facts pos: application-layer bridge between provider-backed metadata and domain statements note: if this file changes, update this header and module README.md.
Package audit orchestrates audit use cases at the application layer. input: SQL text, selected dialect, and infrastructure-backed parser adapters output: application-owned parsed statements for later extraction and rule evaluation pos: application parsing entrypoint between interfaces and parser infrastructure note: if this file changes, update this header and module README.md.
Package audit orchestrates audit use cases at the application layer. input: audit requests carrying SQL text, dialect, optional policy override paths, and optional metadata providers output: end-to-end audit results assembled from policy loading, parsing, extraction, metadata enrichment, and rule evaluation pos: application service entrypoint for the unified offline/metadata-aware SQL audit use case note: if this file changes, update this header and module README.md.
Index ¶
- Variables
- func AuditSQL(ctx context.Context, request Request) (report.Result, error)
- func EvaluateStatements(registry *rule.Registry, statements []spec.Statement) (report.Result, error)
- func Extract(parsed ParsedSQL) ([]spec.Statement, error)
- type MetadataProvider
- type MetadataRequest
- type ParsedSQL
- type ParsedStatement
- type Request
- type Service
Constants ¶
This section is empty.
Variables ¶
var ( // ErrEmptySQL indicates the request did not include auditable SQL text. ErrEmptySQL = errors.New("audit SQL must not be empty") // ErrUnknownDialect indicates the request did not specify a supported dialect. ErrUnknownDialect = errors.New("audit dialect must be mysql or tidb") )
Functions ¶
Types ¶
type MetadataProvider ¶
type MetadataProvider interface {
LoadInstanceFacts(ctx context.Context, dialect spec.Dialect, schema string) (*spec.InstanceFacts, error)
LoadTableSnapshot(ctx context.Context, dialect spec.Dialect, schema string, table string) (*spec.TableSnapshot, error)
}
MetadataProvider supplies optional instance and schema facts for one audit run.
type MetadataRequest ¶
type MetadataRequest struct {
Schema string
Provider MetadataProvider
}
MetadataRequest describes one optional metadata-aware audit invocation.
type ParsedSQL ¶
type ParsedSQL struct {
Dialect spec.Dialect `json:"dialect"`
Statements []ParsedStatement `json:"statements"`
Warnings []string `json:"warnings,omitempty"`
}
ParsedSQL is the application-owned parsing result used by later extraction steps.
type ParsedStatement ¶
type ParsedStatement struct {
Kind spec.Kind `json:"kind"`
RawSQL string `json:"raw_sql"`
// contains filtered or unexported fields
}
ParsedStatement keeps application-facing statement metadata while hiding parser nodes.
type Request ¶
type Request struct {
SQL string
Dialect spec.Dialect
ConfigPath string
Schema string
MetadataProvider MetadataProvider
Metadata *MetadataRequest
}
Request describes one application-level audit invocation.
Source Files