namespace

Documentation

Overview

Define SQL functions that helps to develop plugins

Index

• Variables
• func GetQueryType(query string) (sqlparser.StatementType, sqlparser.Statement, error)
• func GetTableName(plugin string, table string, profile string) string
• func RegisterExternalMySQL(params LoadDatabaseConnectionParams, logger hclog.Logger) (statements []string, args [][]driver.Value, err error)
• func RegisterExternalPostgreSQL(params LoadDatabaseConnectionParams, logger hclog.Logger) (statements []string, args [][]driver.Value, err error)
• func RegisterExternalSQLite(params LoadDatabaseConnectionParams, logger hclog.Logger) (statements []string, args [][]driver.Value, err error)
• func RewriteShowStatement(parsedQuery *sqlparser.Show) (string, []interface{})
• type LoadDatabaseConnectionParams
• type MySQLServer
  • func (s *MySQLServer) Start() error
  • func (s *MySQLServer) Stop() error
• type Namespace
  • func NewNamespace(config NamespaceConfig) (*Namespace, error)
  • func (n *Namespace) GetConnectionString() string
  • func (n *Namespace) Init(config NamespaceConfig) error
  • func (n *Namespace) LoadAnyqueryPlugin(path string, manifest rpc.PluginManifest, userConfig rpc.PluginConfig, ...) error
  • func (n *Namespace) LoadAsAnyqueryCLI(path string) error
  • func (n *Namespace) LoadDatabaseConnection(args LoadDatabaseConnectionParams) error
  • func (n *Namespace) LoadGoPlugin(plugin sqlite3.Module, name string) error
  • func (n *Namespace) LoadSharedExtension(path string, entrypoint string) error
  • func (n *Namespace) Register(registerName string) (*sql.DB, error)
• type NamespaceConfig
• type UserEntry

Variables

var SupportedConnections = []string{"MySQL", "PostgreSQL", "SQLite"}

The list of external connections supported by Anyquery

Functions

func GetQueryType

func GetQueryType(query string) (sqlparser.StatementType, sqlparser.Statement, error)

GetQueryType returns the type of the query (e.g. SELECT, INSERT, SHOW, SET, etc.) Internally, it uses the sqlparser from the vitess project to parse the query and return the type.

If a syntax error is found, it returns an unknown type. Therefore, error will be nil.

func GetTableName

func GetTableName(plugin string, table string, profile string) string

GetTableName returns the table name for a given plugin, table and profile

The table name is constructed by concatenating the plugin, table and profile

func RegisterExternalMySQL

func RegisterExternalMySQL(params LoadDatabaseConnectionParams, logger hclog.Logger) (statements []string, args [][]driver.Value, err error)

Fetch the list of tables from the database and return a list of exec statement to run so that the tables are imported in Anyquery

func RegisterExternalPostgreSQL

func RegisterExternalPostgreSQL(params LoadDatabaseConnectionParams, logger hclog.Logger) (statements []string, args [][]driver.Value, err error)

Fetch the list of tables from the database and return a list of exec statement to run so that the tables are imported in Anyquery

func RegisterExternalSQLite

func RegisterExternalSQLite(params LoadDatabaseConnectionParams, logger hclog.Logger) (statements []string, args [][]driver.Value, err error)

Fetch the list of tables from the database and return a list of exec statement to run so that the tables are imported in Anyquery

func RewriteShowStatement

func RewriteShowStatement(parsedQuery *sqlparser.Show) (string, []interface{})

Take a SHOW statement and return the corresponding SQLite query

Types

type LoadDatabaseConnectionParams

type LoadDatabaseConnectionParams struct {
	// The prefix to use for all the imported tables
	//
	// For example, if you import information_schema.tables from MySQL, and uses the SchemaName "mydb",
	// the table will be imported as mydb.information_schema_tables
	SchemaName string

	// The type of the database. It must be one of the SupportedConnections
	DatabaseType string

	// The connection string to the database
	//
	// For example, for PostgreSQL, it's postgresql://user:password@localhost:5432/dbname
	ConnectionString string

	// A CEL expression to filter the tables to import
	//
	// The expression must return a boolean
	// For example, to import only the tables named "table1" and "table2", you can use "table.name IN ['table1', 'table2']"
	Filter string

	// Additional options to pass to the connection
	Metadata map[string]interface{}
}

A struct to hold all the informations required to import tables from an external database

type MySQLServer

type MySQLServer struct {
	// The address of the server to bind to
	// (e.g. "localhost:3306")
	Address string

	// Auth file is a path to a file that contains
	// the username and passwords to use for the server
	//
	// It follows the format of the Vitess' file based authentication
	// which can be found at:
	// https://vitess.io/docs/19.0/user-guides/configuration-advanced/static-auth/
	//
	// Note: for safety reasons, the file should be readable only by the user
	// running the server
	AuthFile string

	// A map of users that can be used to authenticate to the server
	//
	// The key is the username and the value is an array of UserEntry.
	// Therefore, a user can have multiple passwords to authenticate
	//
	// If AuthFile is provided, this field will be ignored
	// If neither AuthFile nor Users are provided, the server will accept any connection
	Users map[string][]UserEntry

	// SQLite doesn't use the same exact dialect as MySQL.
	// For example, queries like "SHOW TABLES", "SET", "SHOW DATABASES", "USE"
	// are not supported by SQLite and will return an error.
	//
	// If this field is set to true, the server will catch these MySQL-specific
	// queries and return an adequate answer so that MySQL clients can work with it.
	//
	// Note: this is a best-effort implementation and some queries might not work as expected
	MustCatchMySQLSpecific bool

	// The database connection to SQLite used by the server
	//
	// When the server is closed, the connection will not be closed
	// and it is the responsibility of the caller to close it
	DB *sql.DB

	// The logger used by the server
	Logger *log.Logger
	// contains filtered or unexported fields
}

Represent a MySQL-compatible server to run queries on a sql.DB instance

func (*MySQLServer) Start

func (s *MySQLServer) Start() error

Start the MySQL server

func (*MySQLServer) Stop

func (s *MySQLServer) Stop() error

type Namespace

type Namespace struct {
	// contains filtered or unexported fields
}

func NewNamespace

func NewNamespace(config NamespaceConfig) (*Namespace, error)

func (*Namespace) GetConnectionString

func (n *Namespace) GetConnectionString() string

func (*Namespace) Init

func (n *Namespace) Init(config NamespaceConfig) error

func (*Namespace) LoadAnyqueryPlugin

func (n *Namespace) LoadAnyqueryPlugin(path string, manifest rpc.PluginManifest, userConfig rpc.PluginConfig, connectionID int) error

Register a plugin written in Go built for anyquery for each table of the manifest

In the manifest, any zeroed string of table name will be ignored

func (*Namespace) LoadAsAnyqueryCLI

func (n *Namespace) LoadAsAnyqueryCLI(path string) error

LoadAsAnyqueryCLI loads the plugins from the configuration of the CLI

It's useful if you want to mimic the behavior of the CLI (internally, the CLI uses this function to load the plugins)

The path is the absolute path to the database used by the CLI. When a plugin can't be loaded, it will be ignored and logged

func (*Namespace) LoadDatabaseConnection

func (n *Namespace) LoadDatabaseConnection(args LoadDatabaseConnectionParams) error

Import and query tables from an external database

func (*Namespace) LoadGoPlugin

func (n *Namespace) LoadGoPlugin(plugin sqlite3.Module, name string) error

Load a plugin written in Go

Note: the plugin will only be loaded once the namespace is registered

func (*Namespace) LoadSharedExtension

func (n *Namespace) LoadSharedExtension(path string, entrypoint string) error

Load a SQLite extension built as a shared object (.so)

Note: the plugin will only be loaded once the namespace is registered

func (*Namespace) Register

func (n *Namespace) Register(registerName string) (*sql.DB, error)

Register registers the namespace to the database/sql package

It takes the name of the connection to register. If not specified, a random name will be generated

type NamespaceConfig

type NamespaceConfig struct {
	// If InMemory is set to true, the SQLite database will only be stored in memory
	InMemory bool

	// The path to the SQLite database to open
	//
	// If InMemory is set to true, this field will be ignored
	Path string

	// The connection string to use to connect to the database
	//
	// If set, InMemory and Path will be ignored
	ConnectionString string

	// The page cache size in kilobytes
	//
	// By default, it is set to 50000 KB (50 MB)
	PageCacheSize int

	// Enforce foreign key constraints
	EnforceForeignKeys bool

	// The hclog logger to use from hashicorp/go-hclog
	Logger hclog.Logger

	// If ReadOnly is set to true, the database will be opened in read-only mode
	ReadOnly bool

	// If DevMode is set to true, the namespace will be in development mode
	// Some functions will be available to load and unload plugins
	// This can represent a security risk if the server is exposed to the internet
	// Therefore, it's recommended to disable it in production
	DevMode bool
}

type UserEntry

type UserEntry struct {
	// The clear password of the user used to authenticate
	PasswordClear string

	// The native hashed password of the user used to authenticate
	// (recommended to be used instead of PasswordClear)
	//
	// It is the HEX(sha1(sha1(password))) of the password prefixed by "*"
	PasswordHash string
}