output

type FileValidationResult ¶

type FileValidationResult struct {
	Path  string
	Valid bool
	Size  int64
	Error error
}

FileValidationResult contains the result for a single file.

Represents the validation outcome for one SQL file including success status, file metadata, and any validation errors.

Fields:

• Path: File path (absolute or relative)
• Valid: True if validation succeeded, false otherwise
• Size: File size in bytes
• Error: Validation error if validation failed, nil otherwise

Example:

fileResult := FileValidationResult{
    Path:  "query.sql",
    Valid: false,
    Size:  1024,
    Error: errors.New("syntax error at line 5"),
}

type JSONASTRepresentation ¶

type JSONASTRepresentation struct {
	Type       string          `json:"type"`
	Statements []JSONStatement `json:"statements"`
	Count      int             `json:"statement_count"`
}

JSONASTRepresentation represents the AST structure.

Provides a JSON-friendly representation of the Abstract Syntax Tree generated from SQL parsing.

Fields:

• Type: AST type ("AST")
• Statements: Array of top-level SQL statements
• Count: Number of statements in the AST

type JSONInputInfo ¶

type JSONInputInfo struct {
	Type  string   `json:"type"` // "file", "files", "stdin", "directory"
	Files []string `json:"files,omitempty"`
	Count int      `json:"count"`
}

JSONInputInfo contains information about the input.

Describes the input source and files processed in the validation run.

Fields:

• Type: Input type ("file", "files", "stdin", "directory")
• Files: Array of file paths processed
• Count: Number of files processed

type JSONParseError ¶

type JSONParseError struct {
	Message  string        `json:"message"`
	Code     string        `json:"code,omitempty"`
	Type     string        `json:"type"` // "tokenization", "parsing", "io"
	Position *JSONPosition `json:"position,omitempty"`
}

JSONParseError represents a parsing error.

Contains detailed information about parsing failures including error type, message, code, and source position.

Fields:

• Message: Error message text
• Code: Error code (e.g., "E2001") if available
• Type: Error category ("tokenization", "parsing", "io")
• Position: Source position where error occurred (optional)

type JSONParseMetadata ¶

type JSONParseMetadata struct {
	ParserVersion string   `json:"parser_version"`
	SQLCompliance string   `json:"sql_compliance"`
	Features      []string `json:"features"`
}

JSONParseMetadata contains metadata about the parsing.

Provides information about the parser capabilities and configuration.

Fields:

• ParserVersion: Parser version string
• SQLCompliance: SQL standard compliance level (e.g., "~80-85% SQL-99")
• Features: Supported SQL features (CTEs, Window Functions, etc.)

type JSONParseOutput ¶

type JSONParseOutput struct {
	Command string           `json:"command"`
	Input   JSONInputInfo    `json:"input"`
	Status  string           `json:"status"`
	Results *JSONParseResult `json:"results,omitempty"`
	Error   *JSONParseError  `json:"error,omitempty"`
}

JSONParseOutput represents the JSON output format for parse command.

Provides structured JSON output for SQL parsing results, including AST structure, token information, and metadata.

Fields:

• Command: Command name ("parse")
• Input: Input metadata
• Status: Parse status ("success" or "error")
• Results: Parse results (AST, tokens, metadata) if successful
• Error: Error information if parsing failed

type JSONParseResult ¶

type JSONParseResult struct {
	AST        *JSONASTRepresentation `json:"ast,omitempty"`
	Tokens     []JSONToken            `json:"tokens,omitempty"`
	TokenCount int                    `json:"token_count"`
	Metadata   JSONParseMetadata      `json:"metadata"`
}

JSONParseResult contains parse results.

Represents the successful parsing of SQL including AST structure, token information, and parsing metadata.

Fields:

• AST: Abstract Syntax Tree representation
• Tokens: Token stream (optional, if requested)
• TokenCount: Number of tokens generated
• Metadata: Parser metadata (version, compliance, features)

type JSONPosition ¶

type JSONPosition struct {
	Line   int `json:"line"`
	Column int `json:"column"`
	Offset int `json:"offset,omitempty"`
}

JSONPosition represents a position in the source.

Identifies a specific location in the SQL source text using line, column, and optional byte offset.

Fields:

• Line: Line number (1-based)
• Column: Column number (1-based)
• Offset: Byte offset from start (optional)

type JSONStatement ¶

type JSONStatement struct {
	Type     string                 `json:"type"`
	Details  map[string]interface{} `json:"details,omitempty"`
	Position *JSONPosition          `json:"position,omitempty"`
}

JSONStatement represents a single AST statement.

Represents one SQL statement from the AST with type information, details, and optional position information.

Fields:

• Type: Statement type (e.g., "SelectStatement", "InsertStatement")
• Details: Type-specific details (columns, tables, clauses)
• Position: Source position (optional)

type JSONToken ¶

type JSONToken struct {
	Type     string        `json:"type"`
	Value    string        `json:"value"`
	Position *JSONPosition `json:"position"`
}

JSONToken represents a single token.

Represents a lexical token from SQL tokenization with type, value, and source position.

Fields:

• Type: Token type (e.g., "KEYWORD", "IDENTIFIER", "NUMBER")
• Value: Token text value
• Position: Source position (line, column)

type JSONValidationError ¶

type JSONValidationError struct {
	File    string `json:"file"`
	Message string `json:"message"`
	Code    string `json:"code,omitempty"`
	Type    string `json:"type"` // "tokenization", "parsing", "syntax", "io"
}

JSONValidationError represents a single validation error.

Contains detailed information about a validation failure for one file.

Fields:

• File: File path where error occurred
• Message: Error message text
• Code: Error code (e.g., "E1001") if available
• Type: Error category ("tokenization", "parsing", "syntax", "io")

type JSONValidationOutput ¶

type JSONValidationOutput struct {
	Command string                `json:"command"`
	Input   JSONInputInfo         `json:"input"`
	Status  string                `json:"status"`
	Results JSONValidationResults `json:"results"`
	Errors  []JSONValidationError `json:"errors,omitempty"`
	Stats   *JSONValidationStats  `json:"stats,omitempty"`
}

JSONValidationOutput represents the JSON output format for validation command.

Provides structured JSON output for SQL validation results, suitable for programmatic consumption, CI/CD integration, and automated processing.

Fields:

• Command: Command name ("validate")
• Input: Input metadata (type, files, count)
• Status: Overall status ("success", "failure", "no_files")
• Results: Validation results summary
• Errors: Array of validation errors (empty if all valid)
• Stats: Performance statistics (optional)

type JSONValidationResults ¶

type JSONValidationResults struct {
	Valid        bool `json:"valid"`
	TotalFiles   int  `json:"total_files"`
	ValidFiles   int  `json:"valid_files"`
	InvalidFiles int  `json:"invalid_files"`
}

JSONValidationResults contains validation results.

Provides summary statistics about validation outcomes.

Fields:

• Valid: True if all files passed validation
• TotalFiles: Total number of files processed
• ValidFiles: Number of files that passed validation
• InvalidFiles: Number of files with validation errors

type JSONValidationStats ¶

type JSONValidationStats struct {
	Duration      string  `json:"duration"`
	DurationMs    float64 `json:"duration_ms"`
	TotalBytes    int64   `json:"total_bytes"`
	ThroughputFPS float64 `json:"throughput_files_per_sec,omitempty"`
	ThroughputBPS int64   `json:"throughput_bytes_per_sec,omitempty"`
}

JSONValidationStats contains performance statistics.

Provides detailed performance metrics for the validation run.

Fields:

• Duration: Human-readable duration string (e.g., "10ms")
• DurationMs: Duration in milliseconds
• TotalBytes: Total size of processed files in bytes
• ThroughputFPS: Files processed per second
• ThroughputBPS: Bytes processed per second

type SARIF ¶

type SARIF struct {
	Schema  string     `json:"$schema"`
	Version string     `json:"version"`
	Runs    []SARIFRun `json:"runs"`
}

SARIF represents a SARIF 2.1.0 document.

SARIF (Static Analysis Results Interchange Format) is a standard format for representing static analysis results. This implementation complies with SARIF 2.1.0 specification for integration with GitHub Code Scanning and other static analysis tools.

Fields:

• Schema: JSON schema URL for SARIF 2.1.0
• Version: SARIF format version (always "2.1.0")
• Runs: Array of analysis runs (typically one run per invocation)

Specification: https://docs.oasis-open.org/sarif/sarif/v2.1.0/sarif-v2.1.0.html

type SARIFArtifactLocation ¶

type SARIFArtifactLocation struct {
	URI       string `json:"uri"`
	URIBaseID string `json:"uriBaseId,omitempty"`
}

SARIFArtifactLocation identifies the file.

Specifies which file contains the finding using a URI and optional base ID.

Fields:

• URI: File path as URI (forward slashes, relative path)
• URIBaseID: Optional base ID for resolving relative paths ("%SRCROOT%")

type SARIFDriver ¶

type SARIFDriver struct {
	Name            string      `json:"name"`
	Version         string      `json:"version,omitempty"`
	InformationURI  string      `json:"informationUri,omitempty"`
	Rules           []SARIFRule `json:"rules,omitempty"`
	SemanticVersion string      `json:"semanticVersion,omitempty"`
}

SARIFDriver contains tool information.

Provides detailed information about the analysis tool including name, version, and rule definitions.

Fields:

• Name: Tool name ("GoSQLX")
• Version: Tool version (e.g., "1.6.0")
• InformationURI: URL to tool documentation
• Rules: Array of rule definitions
• SemanticVersion: Semantic version string

type SARIFLocation ¶

type SARIFLocation struct {
	PhysicalLocation SARIFPhysicalLocation `json:"physicalLocation"`
}

SARIFLocation specifies where a result was found.

Provides the physical location of a finding in source code.

Fields:

• PhysicalLocation: File and position information

type SARIFMessage ¶

type SARIFMessage struct {
	Text string `json:"text"`
}

SARIFMessage contains text content.

A simple text message used throughout SARIF for descriptions, help text, and result messages.

Fields:

• Text: The message text

type SARIFPhysicalLocation ¶

type SARIFPhysicalLocation struct {
	ArtifactLocation SARIFArtifactLocation `json:"artifactLocation"`
	Region           SARIFRegion           `json:"region"`
}

SARIFPhysicalLocation provides file and region information.

Contains both the file identifier and the specific region within the file where the finding occurred.

Fields:

• ArtifactLocation: File identification
• Region: Line and column information

type SARIFRegion ¶

type SARIFRegion struct {
	StartLine   int `json:"startLine"`
	StartColumn int `json:"startColumn,omitempty"`
	EndLine     int `json:"endLine,omitempty"`
	EndColumn   int `json:"endColumn,omitempty"`
}

SARIFRegion specifies the location within a file.

Defines the specific lines and columns where a finding occurred. Line and column numbers are 1-based per SARIF specification.

Fields:

• StartLine: Starting line number (1-based)
• StartColumn: Starting column number (1-based, optional)
• EndLine: Ending line number (optional)
• EndColumn: Ending column number (optional)

type SARIFResult ¶

type SARIFResult struct {
	RuleID              string            `json:"ruleId"`
	Level               string            `json:"level"`
	Message             SARIFMessage      `json:"message"`
	Locations           []SARIFLocation   `json:"locations"`
	PartialFingerprints map[string]string `json:"partialFingerprints,omitempty"`
}

SARIFResult represents a single finding.

A result represents one specific violation or issue found during analysis. Each result is associated with a rule and has a location in the source code.

Fields:

• RuleID: ID of the rule that was violated
• Level: Severity level ("error", "warning", "note")
• Message: Description of the violation
• Locations: Where the violation occurred (file, line, column)
• PartialFingerprints: Fingerprints for result deduplication

type SARIFRule ¶

type SARIFRule struct {
	ID               string                 `json:"id"`
	Name             string                 `json:"name,omitempty"`
	ShortDescription SARIFMessage           `json:"shortDescription,omitempty"`
	FullDescription  SARIFMessage           `json:"fullDescription,omitempty"`
	Help             SARIFMessage           `json:"help,omitempty"`
	DefaultLevel     string                 `json:"defaultConfiguration,omitempty"`
	Properties       map[string]interface{} `json:"properties,omitempty"`
}

SARIFRule describes a validation rule.

Defines a specific validation rule that can be violated in the analysis. Rules provide metadata about what was checked and how to fix violations.

Fields:

• ID: Unique rule identifier (e.g., "sql-syntax-error")
• Name: Human-readable rule name
• ShortDescription: Brief description of the rule
• FullDescription: Detailed description of what the rule checks
• Help: Guidance on how to fix violations
• DefaultLevel: Default severity level (not used in current implementation)
• Properties: Additional rule metadata (category, tags)

type SARIFRun ¶

type SARIFRun struct {
	Tool    SARIFTool     `json:"tool"`
	Results []SARIFResult `json:"results"`
}

SARIFRun represents a single analysis run.

A run represents a single invocation of an analysis tool on a set of files. Each run contains tool information, rules, and results.

Fields:

• Tool: Information about the analysis tool (GoSQLX)
• Results: Array of findings from the analysis

type SARIFTool ¶

type SARIFTool struct {
	Driver SARIFDriver `json:"driver"`
}

SARIFTool describes the analysis tool.

Contains metadata about the tool that produced the analysis results.

Fields:

• Driver: Tool driver information (name, version, rules)

type ValidationResult ¶

type ValidationResult struct {
	TotalFiles   int
	ValidFiles   int
	InvalidFiles int
	TotalBytes   int64
	Duration     time.Duration
	Files        []FileValidationResult
}

ValidationResult contains the results of a validation run.

This structure aggregates validation results across multiple files, providing summary statistics and individual file results.

Fields:

• TotalFiles: Total number of files processed
• ValidFiles: Number of files that passed validation
• InvalidFiles: Number of files with validation errors
• TotalBytes: Total size of all processed files in bytes
• Duration: Time taken to process all files
• Files: Individual file validation results

Example:

result := &ValidationResult{
    TotalFiles:   2,
    ValidFiles:   1,
    InvalidFiles: 1,
    Duration:     10 * time.Millisecond,
}