added docs to redhsift,bigquery,mssql and updated docs in whole codebase

Signed-off-by: adarsh-jaiss <[email protected]>

Author: Adarsh-jaiss

README.md

@@ -20,9 +20,7 @@ go get github.com/thesaas-company/xray@latest
 - Navigate to the `xray` directory.
 - Run this command to install the dependencies : `go mod install`
 
-## Maintainer
-- [@Adarsh Jaiswal](https://github.com/adarsh-jaiss)
-- [@tqindia](https://github.com/tqindia)
+### Supported Databbases
 
 ## Show Your Support!
 

cli/cmd/root.go

@@ -17,32 +17,38 @@ import (
 	"gopkg.in/yaml.v3"
 )
 
+// Command line flags
 var (
 	verbose bool
 	cfgFile string
 	dbType  string
 )
 
+// QueryResult represents the result of a database query.
 type QueryResult struct {
 	Columns []string        `json:"columns"`
 	Rows    [][]interface{} `json:"rows"`
 	Time    float64         `json:"time"`
 	Error   string          `json:"error"`
 }
 
+// Table represents a table with headers and rows.
 type Table struct {
 	headers []string
 	rows    [][]string
 }
 
+// NewTable creates a new Table with the given headers.
 func NewTable(headers []string) *Table {
 	return &Table{headers: headers}
 }
 
+// AddRow adds a row to the table.
 func (t *Table) AddRow(row []string) {
 	t.rows = append(t.rows, row)
 }
 
+// String returns a string representation of the table.
 func (t *Table) String() string {
 	// Find the maximum width of each column
 	columnWidths := make([]int, len(t.headers))
@@ -84,6 +90,7 @@ func (t *Table) String() string {
 	return result.String()
 }
 
+// toInterfaceSlice converts a slice of strings to a slice of interfaces.
 func toInterfaceSlice(strs []string) []interface{} {
 	result := make([]interface{}, len(strs))
 	for i, s := range strs {
@@ -97,6 +104,7 @@ var shellCmd = &cobra.Command{
 	Use:   "shell",
 	Short: "Interact with databases",
 	Run: func(cmd *cobra.Command, args []string) {
+		// Set up logging
 		if !verbose {
 			logrus.SetOutput(io.Discard)
 		} else {
@@ -114,7 +122,6 @@ var shellCmd = &cobra.Command{
 			fmt.Printf("Error: Failed to read YAML file: %v\n", err)
 			return
 		}
-
 		var cfg config.Config
 		err = yaml.Unmarshal(configData, &cfg)
 		if err != nil {
@@ -187,6 +194,7 @@ var shellCmd = &cobra.Command{
 	},
 }
 
+// Execute runs the command line interface.
 func Execute() {
 	rootCmd := &cobra.Command{Use: "xray"}
 
@@ -215,6 +223,8 @@ func parseDbType(s string) xrayTypes.DbType {
 		return xrayTypes.BigQuery
 	case "redshift":
 		return xrayTypes.Redshift
+	case "mssql":
+		return xrayTypes.MSSQL
 	default:
 		return xrayTypes.MySQL
 	}

client.go

@@ -19,91 +19,92 @@ import (
 // NewClientWithConfig creates a new SQL client with the given configuration and database type.
 // It returns an error if the database type is not supported or if there is a problem creating the client.
 func NewClientWithConfig(dbConfig *config.Config, dbType types.DbType) (types.ISQL, error) {
+	// Create a new SQL client based on the database type
 	switch dbType {
 	case types.MySQL:
-		sqlClient, err := mysql.NewMySQLWithConfig(dbConfig)
+		sqlClient, err := mysql.NewMySQLWithConfig(dbConfig) // NewMySQLWithConfig is a SQL client that connects to a MySQL database using the given configuration.
 		if err != nil {
 			return nil, err
 		}
 		return logger.NewLogger(sqlClient), nil
 	case types.Postgres:
-		sqlClient, err := postgres.NewPostgresWithConfig(dbConfig)
+		sqlClient, err := postgres.NewPostgresWithConfig(dbConfig) // NewPostgresWithConfig is a SQL client that connects to a Postgres database using the given configuration.
 		if err != nil {
 			return nil, err
 		}
 		return logger.NewLogger(sqlClient), nil
 	case types.Snowflake:
-		sqlClient, err := snowflake.NewSnowflakeWithConfig(dbConfig)
+		sqlClient, err := snowflake.NewSnowflakeWithConfig(dbConfig) // NewSnowflakeWithConfig is a SQL client that connects to a Snowflake database using the given configuration.
 		if err != nil {
 			return nil, err
 		}
 		return logger.NewLogger(sqlClient), nil
 	case types.BigQuery:
-		bigqueryClient, err := bigquery.NewBigQueryWithConfig(dbConfig)
+		bigqueryClient, err := bigquery.NewBigQueryWithConfig(dbConfig) // NewBigQueryWithConfig is a SQL client that connects to a BigQuery database using the given configuration.
 		if err != nil {
 			return nil, err
 		}
 		return logger.NewLogger(bigqueryClient), nil
 	case types.Redshift:
-		redshiftClient, err := redshift.NewRedshiftWithConfig(dbConfig)
+		redshiftClient, err := redshift.NewRedshiftWithConfig(dbConfig) // NewRedshiftWithConfig is a SQL client that connects to a Redshift database using the given configuration.
 		if err != nil {
 			return nil, err
 		}
 		return logger.NewLogger(redshiftClient), nil
 	case types.MSSQL:
-		mssqlClient, err := mssql.NewMSSQLFromConfig(dbConfig)
+		mssqlClient, err := mssql.NewMSSQLFromConfig(dbConfig) // NewMSSQLFromConfig is a SQL client that connects to a MSSQL database using the given configuration.
 		if err != nil {
 			return nil, err
 		}
 		return logger.NewLogger(mssqlClient), nil
 
 	default:
-		return nil, fmt.Errorf("unsupported database type: %s", dbType)
+		return nil, fmt.Errorf("unsupported database type: %s", dbType) // Return an error if the database type is not supported.
 	}
 }
 
 // NewClient creates a new SQL client with the given database client and database type.
 // It returns an error if the database type is not supported or if there is a problem creating the client.
 func NewClient(dbClient *sql.DB, dbType types.DbType) (types.ISQL, error) {
-
+	// Create a new SQL client based on the database type
 	switch dbType {
 	case types.MySQL:
-		sqlClient, err := mysql.NewMySQL(dbClient)
+		sqlClient, err := mysql.NewMySQL(dbClient) // NewMySQL is a SQL client that connects to a MySQL database using the given database client.
 		if err != nil {
 			return nil, err
 		}
 		return logger.NewLogger(sqlClient), nil
 	case types.Postgres:
-		sqlClient, err := postgres.NewPostgres(dbClient)
+		sqlClient, err := postgres.NewPostgres(dbClient) // NewPostgres is a SQL client that connects to a Postgres database using the given database client.
 		if err != nil {
 			return nil, err
 		}
 		return logger.NewLogger(sqlClient), nil
 	case types.Snowflake:
-		sqlClient, err := snowflake.NewSnowflake(dbClient)
+		sqlClient, err := snowflake.NewSnowflake(dbClient) // NewSnowflake is a SQL client that connects to a Snowflake database using the given database client.
 		if err != nil {
 			return nil, err
 		}
 		return logger.NewLogger(sqlClient), nil
 	case types.BigQuery:
-		BigQueryClient, err := bigquery.NewBigQuery(dbClient)
+		BigQueryClient, err := bigquery.NewBigQuery(dbClient) // NewBigQuery is a SQL client that connects to a BigQuery database using the given database client.
 		if err != nil {
 			return nil, err
 		}
 		return logger.NewLogger(BigQueryClient), nil
 	case types.Redshift:
-		redshiftClient, err := redshift.NewRedshift(dbClient)
+		redshiftClient, err := redshift.NewRedshift(dbClient) // NewRedshift is a SQL client that connects to a Redshift database using the given database client.
 		if err != nil {
 			return nil, err
 		}
 		return logger.NewLogger(redshiftClient), nil
 	case types.MSSQL:
-		mssqlClient, err := mssql.NewMSSQL(dbClient)
+		mssqlClient, err := mssql.NewMSSQL(dbClient) // NewMSSQL is a SQL client that connects to a MSSQL database using the given database client.
 		if err != nil {
 			return nil, err
 		}
 		return logger.NewLogger(mssqlClient), nil
 	default:
-		return nil, fmt.Errorf("unsupported database type: %s", dbType)
+		return nil, fmt.Errorf("unsupported database type: %s", dbType) // Return an error if the database type is not supported.
 	}
 }

config/config.go

@@ -47,24 +47,6 @@ type Config struct {
 
 	// Server is the MSSQL database server.
 	Server string `yaml:"server" pflag:",Database server"`
-
-	// AWS holds the AWS configuration details.
-	// AWS AWS `yaml:"aws"`
 }
 
-// type AWS struct {
-// 	// Region is the AWS region.
-// 	Region string `yaml:"region" pflag:",AWS region"`
-
-// 	// AccessKey is the AWS access key.
-// 	AccessKey string `yaml:"access_key" pflag:",AWS access key"`
-
-// 	// SecretKey is the AWS secret key.
-// 	SecretAccessKey string `yaml:"secret_key" pflag:",AWS secret key"`
-
-// 	// ClusterIdentifier is the AWS cluster identifier.
-// 	ClusterIdentifier string `yaml:"cluster_identifier" pflag:",AWS cluster identifier"`
 
-// 	// SecretArn is the AWS secret ARN.
-// 	SecretArn string `yaml:"secret_arn" pflag:",AWS secret ARN"`
-// }

databases/bigquery/bigquery.go

@@ -35,6 +35,7 @@ func NewBigQuery(client *sql.DB) (types.ISQL, error) {
 }
 
 // NewBigQueryWithConfig creates a new instance of BigQuery with the provided configuration.
+// It returns an instance of types.ISQL and an error.
 func NewBigQueryWithConfig(cfg *config.Config) (types.ISQL, error) {
 	if os.Getenv(GOOGLE_APPLICATION_CREDENTIALS) == "" || len(os.Getenv(GOOGLE_APPLICATION_CREDENTIALS)) == 0 {
 		return nil, fmt.Errorf("please set %s env variable for the database", GOOGLE_APPLICATION_CREDENTIALS)
@@ -70,7 +71,7 @@ func (b *BigQuery) Schema(table string) (types.Table, error) {
 		}
 	}()
 
-	// scanning the result into and append it into a variable
+	// scanning the result into a variable and append it into a the slice
 	var columns []types.Column
 	columnNames, err := rows.Columns()
 	if err != nil {
@@ -104,6 +105,8 @@ func (b *BigQuery) Schema(table string) (types.Table, error) {
 
 }
 
+// Execute executes a query on BigQuery.
+// It takes a query string as input and returns the result as a byte slice and an error.
 func (b *BigQuery) Execute(query string) ([]byte, error) {
 	rows, err := b.Client.Query(query)
 	if err != nil {
@@ -161,7 +164,6 @@ func (b *BigQuery) Execute(query string) ([]byte, error) {
 
 // Tables returns a list of tables in a dataset.
 // It takes a dataset name as input and returns a slice of strings and an error.
-
 func (b *BigQuery) Tables(dataset string) ([]string, error) {
 	// res, err := b.Client.Query("SELECT table_name FROM INFORMATION_SCHEMA.TABLES WHERE table_schema = '" + Dataset + "'")
 
@@ -207,6 +209,7 @@ func (b *BigQuery) GenerateCreateTableQuery(table types.Table) string {
 	return query
 }
 
+// convertTypeToBigQuery converts a Data type to a BigQuery SQL Data type.
 func convertTypeToBigQuery(dataType string) string {
 	// Map column types to BigQuery equivalents
 	switch dataType {

databases/bigquery/bigquery_test.go

@@ -58,11 +58,10 @@ func TestSchema(t *testing.T) {
 
 }
 
-// TestExecute is a unit test function that tests the Execute method of the BigQuery struct.
+// TestTables is a unit test function that tests the Tables method of the BigQuery struct.
 // It creates a mock instance of BigQuery, sets the expected return values, and calls the method under test.
 // It then asserts the expected return values and checks if the method was called with the correct arguments.
-
-func TestGetTableName(t *testing.T) {
+func TestTables(t *testing.T) {
 	// create a new mock database connection
 	db, mock := MockDB()
 	defer func() {
@@ -96,6 +95,10 @@ func TestGetTableName(t *testing.T) {
 	}
 }
 
+
+// TestExecute is a unit test function that tests the Execute method of the BigQuery struct.
+// It creates a mock instance of BigQuery, sets the expected return values, and calls the method under test.
+// It then asserts the expected return values and checks if the method was called with the correct arguments.
 func TestExecute(t *testing.T) {
 	// create a new mock database connection
 	db, mock := MockDB()
@@ -152,6 +155,9 @@ func TestExecute(t *testing.T) {
 	}
 }
 
+// TestGenerateCreateTablequeryis a unit test function that tests the TestGenerateCreateTablequery method of the BigQuery struct.
+// It creates a mock instance of BigQuery, sets the expected return values, and calls the method under test.
+// It then asserts the expected return values and checks if the method was called with the correct arguments.
 func TestGenerateCreateTablequery(t *testing.T) {
 	db, mock := MockDB()
 	defer func() {

databases/mssql/mssql.go

@@ -13,27 +13,32 @@ import (
 	"github.com/thesaas-company/xray/types"
 )
 
+// DB_PASSWORD is the name of the environment variable that stores the database password.
 var DB_PASSWORD = "DB_PASSWORD"
 
-const (
-	MSSQL_SCHEMA_QUERY = "SELECT COLUMN_NAME, DATA_TYPE, IS_NULLABLE, COLUMN_DEFAULT, ORDINAL_POSITION, CHARACTER_MAXIMUM_LENGTH FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME = '%s'"
-	MSSQL_TABLES_QUERY = "USE %s; SELECT table_name FROM INFORMATION_SCHEMA.TABLES;"
-)
+// MSSQL_SCHEMA_QUERY is the SQL query for retrieving table schema.
+const MSSQL_SCHEMA_QUERY = "SELECT COLUMN_NAME, DATA_TYPE, IS_NULLABLE, COLUMN_DEFAULT, ORDINAL_POSITION, CHARACTER_MAXIMUM_LENGTH FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME = '%s'"
+
+// MSSQL_TABLES_QUERY is the SQL query for listing tables within a database.
+const MSSQL_TABLES_QUERY = "USE %s; SELECT table_name FROM INFORMATION_SCHEMA.TABLES;"
 
+// MSSQL represents the MSSQL database implementation.
 type MSSQL struct {
 	Client *sql.DB
 	Config *config.Config
 }
 
+// NewMSSQL creates a new MSSQL instance with the given client.
 func NewMSSQL(client *sql.DB) (types.ISQL, error) {
 	return &MSSQL{
 		Client: client,
 		Config: &config.Config{},
 	}, nil
 }
 
+// NewMSSQLFromConfig creates a new MSSQL instance with the given configuration.
 func NewMSSQLFromConfig(config *config.Config) (types.ISQL, error) {
-	if os.Getenv(DB_PASSWORD) == "" || len(os.Getenv(DB_PASSWORD)) == 0 { // added mysql to be more verbose about the db type
+	if os.Getenv(DB_PASSWORD) == "" || len(os.Getenv(DB_PASSWORD)) == 0 {
 		return nil, fmt.Errorf("please set %s env variable for the database", DB_PASSWORD)
 	}
 
@@ -51,6 +56,8 @@ func NewMSSQLFromConfig(config *config.Config) (types.ISQL, error) {
 	}, nil
 }
 
+// Schema retrieves the table schema for the given table name.
+// It takes the table name as an argument and returns the table schema as a types.Table object.
 func (m *MSSQL) Schema(table string) (types.Table, error) {
 	query := fmt.Sprintf(MSSQL_SCHEMA_QUERY, table)
 	rows, err := m.Client.Query(query)
@@ -95,6 +102,8 @@ func (m *MSSQL) Schema(table string) (types.Table, error) {
 	}, nil
 }
 
+// Tables lists the tables within the given database in a bigquery.
+// It takes the database name as an argument and returns a slice of table names.
 func (m *MSSQL) Tables(databaseName string) ([]string, error) {
 	query := fmt.Sprintf(MSSQL_TABLES_QUERY, databaseName)
 	rows, err := m.Client.Query(query)
@@ -122,9 +131,10 @@ func (m *MSSQL) Tables(databaseName string) ([]string, error) {
 	}
 
 	return tables, nil
-
 }
 
+// Execute executes the given SQL query and returns the result as JSON.
+// It takes the SQL query as an argument.
 func (m *MSSQL) Execute(query string) ([]byte, error) {
 	rows, err := m.Client.Query(query)
 	if err != nil {
@@ -174,6 +184,8 @@ func (m *MSSQL) Execute(query string) ([]byte, error) {
 	return jsonData, nil
 }
 
+// GenerateCreateTableQuery generates the SQL query for creating a table based on the given table definition.
+// It takes the table definition as an argument and returns the SQL query as a string.
 func (m *MSSQL) GenerateCreateTableQuery(table types.Table) string {
 	query := "CREATE TABLE [" + table.Name + "] ("
 	pk := ""