Repository: turbot/steampipe-plugin-aws (language: go)

Issue:
Create QuickSight tables
Request for new tables

1. QuickSight Users/Groups, we'd use this to reduce cost, and ensure security by determining which role/IdP each registered QuickSight user is.
2. QuickSight DataSource/DataSets, would allow us to view which data is connected to QuickSight.
3. QuickSight Account/VPC Settings would allow use to verify correct security controls, like VPC attached or non-public dashboards.

API https://docs.aws.amazon.com/quicksight/latest/APIReference/API_Reference.html

**Describe the solution you'd like**
A clear and concise description of what you want to happen.

**Describe alternatives you've considered**
A clear and concise description of any alternative solutions or features you've considered.

**Additional context**
Add any other context or screenshots about the feature request here.



Discussion / hints:

Fix patch:
diff --git a/aws/plugin.go b/aws/plugin.go
index c8d556d45..9f79ea2d6 100644
--- a/aws/plugin.go
+++ b/aws/plugin.go
@@ -405,6 +405,13 @@ func Plugin(ctx context.Context) *plugin.Plugin {
 			"aws_pipes_pipe":                                               tableAwsPipes(ctx),
 			"aws_pricing_product":                                          tableAwsPricingProduct(ctx),
 			"aws_pricing_service_attribute":                                tableAwsPricingServiceAttribute(ctx),
+			"aws_quicksight_account_setting":                               tableAwsQuickSightAccountSetting(ctx),
+			"aws_quicksight_data_set":                                      tableAwsQuickSightDataset(ctx),
+			"aws_quicksight_data_source":                                   tableAwsQuickSightDatasource(ctx),
+			"aws_quicksight_group":                                         tableAwsQuickSightGroup(ctx),
+			"aws_quicksight_namespace":                                     tableAwsQuickSightNamespace(ctx),
+			"aws_quicksight_user":                                          tableAwsQuickSightUser(ctx),
+			"aws_quicksight_vpc_connection":                                tableAwsQuickSightVpcConnection(ctx),
 			"aws_ram_principal_association":                                tableAwsRAMPrincipalAssociation(ctx),
 			"aws_ram_resource_association":                                 tableAwsRAMResourceAssociation(ctx),
 			"aws_rds_db_cluster":                                           tableAwsRDSDBCluster(ctx),
diff --git a/aws/service.go b/aws/service.go
index 44c00b4da..0066ae9d0 100644
--- a/aws/service.go
+++ b/aws/service.go
@@ -107,6 +107,7 @@ import (
 	"github.com/aws/aws-sdk-go-v2/service/pinpoint"
 	"github.com/aws/aws-sdk-go-v2/service/pipes"
 	"github.com/aws/aws-sdk-go-v2/service/pricing"
+	"github.com/aws/aws-sdk-go-v2/service/quicksight"
 	"github.com/aws/aws-sdk-go-v2/service/ram"
 	"github.com/aws/aws-sdk-go-v2/service/rds"
 	"github.com/aws/aws-sdk-go-v2/service/redshift"
@@ -1187,6 +1188,15 @@ func PricingClient(ctx context.Context, d *plugin.QueryData) (*pricing.Client, e
 	return pricing.NewFromConfig(*cfg), nil
 }
 
+// QuickSightClient returns the client for the Amazon QuickSight service
+func QuickSightClient(ctx context.Context, d *plugin.QueryData) (*quicksight.Client, error) {
+	cfg, err := getClientForQueryRegion(ctx, d)
+	if err != nil {
+		return nil, err
+	}
+	return quicksight.NewFromConfig(*cfg), nil
+}
+
 func RAMClient(ctx context.Context, d *plugin.QueryData) (*ram.Client, error) {
 	cfg, err := getClientForQueryRegion(ctx, d)
 	if err != nil {
diff --git a/aws/table_aws_quicksight_account_setting.go b/aws/table_aws_quicksight_account_setting.go
new file mode 100644
index 000000000..d755201a7
--- /dev/null
+++ b/aws/table_aws_quicksight_account_setting.go
@@ -0,0 +1,125 @@
+package aws
+
+import (
+	"context"
+
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/quicksight"
+
+	"github.com/turbot/steampipe-plugin-sdk/v5/grpc/proto"
+	"github.com/turbot/steampipe-plugin-sdk/v5/plugin"
+	"github.com/turbot/steampipe-plugin-sdk/v5/plugin/transform"
+)
+
+//// TABLE DEFINITION
+
+func tableAwsQuickSightAccountSetting(_ context.Context) *plugin.Table {
+	return &plugin.Table{
+		Name:        "aws_quicksight_account_setting",
+		Description: "AWS QuickSight Account Setting",
+		List: &plugin.ListConfig{
+			Hydrate: listAwsQuickSightAccountSettings,
+			IgnoreConfig: &plugin.IgnoreConfig{
+				ShouldIgnoreErrorFunc: shouldIgnoreErrors([]string{"ResourceNotFoundException"}),
+			},
+			KeyColumns: []*plugin.KeyColumn{
+				{Name: "region", Require: plugin.Required},
+				{Name: "quicksight_account_id", Require: plugin.Optional},
+			},
+			Tags: map[string]string{"service": "quicksight", "action": "DescribeAccountSettings"},
+		},
+		GetMatrixItemFunc: SupportedRegionMatrix(AWS_QUICKSIGHT_SERVICE_ID),
+		Columns: awsRegionalColumns([]*plugin.Column{
+			{
+				Name:        "account_name",
+				Description: "The account name displayed for the account.",
+				Type:        proto.ColumnType_STRING,
+				Transform:   transform.FromField("AccountSettings.AccountName"),
+			},
+			// As we have already a column "account_id" as a common column for all the tables, we have renamed the column to "quicksight_account_id"
+			{
+				Name:        "quicksight_account_id",
+				Description: "The ID for the Amazon Web Services account that contains the settings that you want to list.",
+				Type:        proto.ColumnType_STRING,
+				Transform:   transform.FromQual("quicksight_account_id"),
+			},
+			{
+				Name:        "edition",
+				Description: "The edition of Amazon QuickSight that you're currently subscribed to: Enterprise edition or Standard edition.",
+				Type:        proto.ColumnType_STRING,
+				Transform:   transform.FromField("AccountSettings.Edition"),
+			},
+			{
+				Name:        "default_namespace",
+				Description: "The default namespace for this AWS account.",
+				Type:        proto.ColumnType_STRING,
+				Transform:   transform.FromField("AccountSettings.DefaultNamespace"),
+			},
+			{
+				Name:        "notification_email",
+				Description: "The email address that QuickSight uses to send notifications.",
+				Type:        proto.ColumnType_STRING,
+				Transform:   transform.FromField("AccountSettings.NotificationEmail"),
+			},
+			{
+				Name:        "termination_protection_enabled",
+				Description: "A boolean value that indicates whether termination protection is enabled.",
+				Type:        proto.ColumnType_BOOL,
+				Transform:   transform.FromField("AccountSettings.TerminationProtectionEnabled"),
+			},
+			{
+				Name:        "public_sharing_enabled",
+				Description: "A boolean value that indicates whether public sharing is enabled.",
+				Type:        proto.ColumnType_BOOL,
+				Transform:   transform.FromField("AccountSettings.PublicSharingEnabled"),
+			},
+
+			// Standard columns
+			{
+				Name:        "title",
+				Description: resourceInterfaceDescription("title"),
+				Type:        proto.ColumnType_STRING,
+				Transform:   transform.FromField("AccountSettings.AccountName"),
+			},
+		}),
+	}
+}
+
+//// LIST FUNCTION
+
+func listAwsQuickSightAccountSettings(ctx context.Context, d *plugin.QueryData, h *plugin.HydrateData) (interface{}, error) {
+	// Create client
+	svc, err := QuickSightClient(ctx, d)
+	if err != nil {
+		plugin.Logger(ctx).Error("aws_quicksight_account_setting.listAwsQuickSightAccountSettings", "connection_error", err)
+		return nil, err
+	}
+
+	accountId := d.EqualsQuals["quicksight_account_id"].GetStringValue()
+	// Get AWS Account ID
+	commonData, err := getCommonColumns(ctx, d, h)
+	if err != nil {
+		return nil, err
+	}
+	commonColumnData := commonData.(*awsCommonColumnData)
+
+	if accountId == "" {
+		accountId = commonColumnData.AccountId
+	}
+
+	// Build the params
+	params := &quicksight.DescribeAccountSettingsInput{
+		AwsAccountId: aws.String(accountId),
+	}
+
+	// Get call
+	data, err := svc.DescribeAccountSettings(ctx, params)
+	if err != nil {
+		plugin.Logger(ctx).Error("aws_quicksight_account_setting.listAwsQuickSightAccountSettings", "api_error", err)
+		return nil, err
+	}
+
+	d.StreamListItem(ctx, data)
+
+	return nil, nil
+}
diff --git a/aws/table_aws_quicksight_data_set.go b/aws/table_aws_quicksight_data_set.go
new file mode 100644
index 000000000..fc2f3bbe7
--- /dev/null
+++ b/aws/table_aws_quicksight_data_set.go
@@ -0,0 +1,242 @@
+package aws
+
+import (
+	"context"
+
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/quicksight"
+	"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
+
+	"github.com/turbot/steampipe-plugin-sdk/v5/grpc/proto"
+	"github.com/turbot/steampipe-plugin-sdk/v5/plugin"
+	"github.com/turbot/steampipe-plugin-sdk/v5/plugin/transform"
+)
+
+//// TABLE DEFINITION
+
+func tableAwsQuickSightDataset(_ context.Context) *plugin.Table {
+	return &plugin.Table{
+		Name:        "aws_quicksight_data_set",
+		Description: "AWS QuickSight Dataset",
+		Get: &plugin.GetConfig{
+			KeyColumns: []*plugin.KeyColumn{
+				{Name: "dataset_id", Require: plugin.Required},
+				{Name: "quicksight_account_id", Require: plugin.Optional},
+			},
+			Hydrate: getAwsQuickSightDataset,
+			IgnoreConfig: &plugin.IgnoreConfig{
+				ShouldIgnoreErrorFunc: shouldIgnoreErrors([]string{"ResourceNotFoundException"}),
+			},
+			Tags: map[string]string{"service": "quicksight", "action": "DescribeDataSet"},
+		},
+		List: &plugin.ListConfig{
+			Hydrate: listAwsQuickSightDatasets,
+			KeyColumns: []*plugin.KeyColumn{
+				{Name: "quicksight_account_id", Require: plugin.Optional},
+			},
+			Tags: map[string]string{"service": "quicksight", "action": "ListDataSets"},
+		},
+		GetMatrixItemFunc: SupportedRegionMatrix(AWS_QUICKSIGHT_SERVICE_ID),
+		Columns: awsRegionalColumns([]*plugin.Column{
+			{
+				Name:        "name",
+				Description: "A display name for the dataset.",
+				Type:        proto.ColumnType_STRING,
+			},
+			{
+				Name:        "dataset_id",
+				Description: "The ID of the dataset.",
+				Type:        proto.ColumnType_STRING,
+				Transform:   transform.FromField("DataSetId"),
+			},
+			// As we have already a column "account_id" as a common column for all the tables, we have renamed the column to "quicksight_account_id"
+			{
+				Name:        "quicksight_account_id",
+				Description: "The Amazon Web Services account ID where the dataset is located.",
+				Type:        proto.ColumnType_STRING,
+				Transform:   transform.FromQual("quicksight_account_id"),
+			},
+			{
+				Name:        "arn",
+				Description: "The Amazon Resource Name (ARN) of the resource.",
+				Type:        proto.ColumnType_STRING,
+			},
+			{
+				Name:        "created_time",
+				Description: "The time that this dataset was created.",
+				Type:        proto.ColumnType_TIMESTAMP,
+			},
+			{
+				Name:        "last_updated_time",
+				Description: "The last time that this dataset was updated.",
+				Type:        proto.ColumnType_TIMESTAMP,
+			},
+			{
+				Name:        "import_mode",
+				Description: "A value that indicates whether you want to import the data into SPICE.",
+				Type:        proto.ColumnType_STRING,
+			},
+			{
+				Name:        "row_level_permission_data_set",
+				Description: "The row-level security configuration for the dataset.",
+				Type:        proto.ColumnType_JSON,
+				Transform:   transform.FromField("RowLevelPermissionDataSet"),
+			},
+			{
+				Name:        "column_groups",
+				Description: "Groupings of columns that work together in certain Amazon QuickSight features.",
+				Type:        proto.ColumnType_JSON,
+				Hydrate:     getAwsQuickSightDataset,
+			},
+			{
+				Name:        "column_level_permission_rules",
+				Description: "A set of one or more definitions of a ColumnLevelPermissionRule.",
+				Type:        proto.ColumnType_JSON,
+				Hydrate:     getAwsQuickSightDataset,
+			},
+			{
+				Name:        "data_set_usage_configuration",
+				Description: "The usage configuration to apply to child datasets that reference this dataset as a source.",
+				Type:        proto.ColumnType_JSON,
+				Hydrate:     getAwsQuickSightDataset,
+			},
+			{
+				Name:        "logical_table_map",
+				Description: "Configures the combination and transformation of the data from the physical tables.",
+				Type:        proto.ColumnType_JSON,
+				Hydrate:     getAwsQuickSightDataset,
+			},
+			{
+				Name:        "output_columns",
+				Description: "Output columns for the dataset.",
+				Type:        proto.ColumnType_JSON,
+				Hydrate:     getAwsQuickSightDataset,
+			},
+			{
+				Name:        "physical_table_map",
+				Description: "Declares the physical tables that are available in the underlying data sources.",
+				Type:        proto.ColumnType_JSON,
+				Hydrate:     getAwsQuickSightDataset,
+			},
+
+			// Steampipe Standard columns
+			{
+				Name:        "title",
+				Description: resourceInterfaceDescription("title"),
+				Type:        proto.ColumnType_STRING,
+				Transform:   transform.FromField("Name"),
+			},
+		}),
+	}
+}
+
+//// LIST FUNCTION
+
+func listAwsQuickSightDatasets(ctx context.Context, d *plugin.QueryData, h *plugin.HydrateData) (interface{}, error) {
+	// Create client
+	svc, err := QuickSightClient(ctx, d)
+	if err != nil {
+		plugin.Logger(ctx).Error("aws_quicksight_data_set.listAwsQuickSightDatasets", "connection_error", err)
+		return nil, err
+	}
+
+	accountId := d.EqualsQuals["quicksight_account_id"].GetStringValue()
+
+	// Get AWS Account ID
+	commonData, err := getCommonColumns(ctx, d, h)
+	if err != nil {
+		return nil, err
+	}
+	commonColumnData := commonData.(*awsCommonColumnData)
+
+	if accountId == "" {
+		accountId = commonColumnData.AccountId
+	}
+
+	// Limiting the results
+	maxLimit := int32(100)
+	if d.QueryContext.Limit != nil {
+		limit := int32(*d.QueryContext.Limit)
+		if limit < maxLimit {
+			maxLimit = limit
+		}
+	}
+
+	input := &quicksight.ListDataSetsInput{
+		AwsAccountId: aws.String(accountId),
+		MaxResults:   aws.Int32(maxLimit),
+	}
+
+	paginator := quicksight.NewListDataSetsPaginator(svc, input, func(o *quicksight.ListDataSetsPaginatorOptions) {
+		o.Limit = maxLimit
+		o.StopOnDuplicateToken = true
+	})
+
+	// List call
+	for paginator.HasMorePages() {
+		// apply rate limiting
+		d.WaitForListRateLimit(ctx)
+
+		output, err := paginator.NextPage(ctx)
+		if err != nil {
+			plugin.Logger(ctx).Error("aws_quicksight_data_set.listAwsQuickSightDatasets", "api_error", err)
+			return nil, err
+		}
+
+		for _, item := range output.DataSetSummaries {
+			d.StreamListItem(ctx, item)
+
+			// Context may get cancelled due to manual cancellation or if the limit has been reached
+			if d.RowsRemaining(ctx) == 0 {
+				return nil, nil
+			}
+		}
+	}
+
+	return nil, nil
+}
+
+//// HYDRATE FUNCTIONS
+
+func getAwsQuickSightDataset(ctx context.Context, d *plugin.QueryData, h *plugin.HydrateData) (interface{}, error) {
+	// Create client
+	svc, err := QuickSightClient(ctx, d)
+	if err != nil {
+		plugin.Logger(ctx).Error("aws_quicksight_data_set.getAwsQuickSightDataset", "connection_error", err)
+		return nil, err
+	}
+
+	var datasetID string
+	if h.Item != nil {
+		datasetID = *h.Item.(types.DataSetSummary).DataSetId
+	} else {
+		datasetID = d.EqualsQuals["dataset_id"].GetStringValue()
+	}
+
+	accountId := d.EqualsQuals["quicksight_account_id"].GetStringValue()
+	// Get AWS Account ID
+	commonData, err := getCommonColumns(ctx, d, h)
+	if err != nil {
+		return nil, err
+	}
+	commonColumnData := commonData.(*awsCommonColumnData)
+
+	if accountId == "" {
+		accountId = commonColumnData.AccountId
+	}
+
+	// Build the params
+	params := &quicksight.DescribeDataSetInput{
+		AwsAccountId: aws.String(accountId),
+		DataSetId:    aws.String(datasetID),
+	}
+
+	// Get call
+	data, err := svc.DescribeDataSet(ctx, params)
+	if err != nil {
+		plugin.Logger(ctx).Error("aws_quicksight_data_set.getAwsQuickSightDataset", "api_error", err)
+		return nil, err
+	}
+
+	return *data.DataSet, nil
+}
diff --git a/aws/table_aws_quicksight_data_source.go b/aws/table_aws_quicksight_data_source.go
new file mode 100644
index 000000000..6fc1a23f8
--- /dev/null
+++ b/aws/table_aws_quicksight_data_source.go
@@ -0,0 +1,230 @@
+package aws
+
+import (
+	"context"
+
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/quicksight"
+	"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
+
+	"github.com/turbot/steampipe-plugin-sdk/v5/grpc/proto"
+	"github.com/turbot/steampipe-plugin-sdk/v5/plugin"
+	"github.com/turbot/steampipe-plugin-sdk/v5/plugin/transform"
+)
+
+//// TABLE DEFINITION
+
+func tableAwsQuickSightDatasource(_ context.Context) *plugin.Table {
+	return &plugin.Table{
+		Name:        "aws_quicksight_data_source",
+		Description: "AWS QuickSight Data Source",
+		Get: &plugin.GetConfig{
+			KeyColumns: []*plugin.KeyColumn{
+				{Name: "data_source_id", Require: plugin.Required},
+				{Name: "quicksight_account_id", Require: plugin.Optional},
+			},
+			Hydrate: getAwsQuickSightDatasource,
+			Tags:    map[string]string{"service": "quicksight", "action": "DescribeDataSource"},
+			IgnoreConfig: &plugin.IgnoreConfig{
+				ShouldIgnoreErrorFunc: shouldIgnoreErrors([]string{"ResourceNotFoundException"}),
+			},
+		},
+		List: &plugin.ListConfig{
+			Hydrate: listAwsQuickSightDatasources,
+			KeyColumns: []*plugin.KeyColumn{
+				{Name: "quicksight_account_id", Require: plugin.Optional},
+			},
+			Tags: map[string]string{"service": "quicksight", "action": "ListDataSources"},
+		},
+		GetMatrixItemFunc: SupportedRegionMatrix(AWS_QUICKSIGHT_SERVICE_ID),
+		Columns: awsRegionalColumns([]*plugin.Column{
+			{
+				Name:        "name",
+				Description: "A display name for the data source.",
+				Type:        proto.ColumnType_STRING,
+			},
+			{
+				Name:        "data_source_id",
+				Description: "The ID of the data source.",
+				Type:        proto.ColumnType_STRING,
+				Transform:   transform.FromField("DataSourceId"),
+			},
+			// As we have already a column "account_id" as a common column for all the tables, we have renamed the column to "quicksight_account_id"
+			{
+				Name:        "quicksight_account_id",
+				Description: "The Amazon Web Services account ID where the data source is located.",
+				Type:        proto.ColumnType_STRING,
+				Transform:   transform.FromQual("quicksight_account_id"),
+			},
+			{
+				Name:        "arn",
+				Description: "The Amazon Resource Name (ARN) of the data source.",
+				Type:        proto.ColumnType_STRING,
+			},
+			{
+				Name:        "created_time",
+				Description: "The time that this data source was created.",
+				Type:        proto.ColumnType_TIMESTAMP,
+			},
+			{
+				Name:        "last_updated_time",
+				Description: "The last time that this data source was updated.",
+				Type:        proto.ColumnType_TIMESTAMP,
+			},
+			{
+				Name:        "status",
+				Description: "The status of the data source.",
+				Type:        proto.ColumnType_STRING,
+			},
+			{
+				Name:        "type",
+				Description: "The type of the data source.",
+				Type:        proto.ColumnType_STRING,
+			},
+			{
+				Name:        "vpc_connection_properties",
+				Description: "The VPC connection properties of the data source.",
+				Type:        proto.ColumnType_JSON,
+			},
+			{
+				Name:        "ssl_properties",
+				Description: "Secure Socket Layer (SSL) properties that apply when QuickSight connects to your underlying data source.",
+				Type:        proto.ColumnType_JSON,
+			},
+			{
+				Name:        "error_info",
+				Description: "Error information from the last update or the creation of the data source.",
+				Type:        proto.ColumnType_JSON,
+			},
+			{
+				Name:        "data_source_parameters",
+				Description: "The parameters that Amazon QuickSight uses to connect to your underlying data source.",
+				Type:        proto.ColumnType_JSON,
+			},
+			{
+				Name:        "alternate_data_source_parameters",
+				Description: "A list of alternate data source parameters.",
+				Type:        proto.ColumnType_JSON,
+			},
+
+			// Steampipe Standard columns
+			{
+				Name:        "title",
+				Description: resourceInterfaceDescription("title"),
+				Type:        proto.ColumnType_STRING,
+				Transform:   transform.FromField("Name"),
+			},
+		}),
+	}
+}
+
+//// LIST FUNCTION
+
+func listAwsQuickSightDatasources(ctx context.Context, d *plugin.QueryData, h *plugin.HydrateData) (interface{}, error) {
+	// Create client
+	svc, err := QuickSightClient(ctx, d)
+	if err != nil {
+		plugin.Logger(ctx).Error("aws_quicksight_data_source.listAwsQuickSightDatasources", "connection_error", err)
+		return nil, err
+	}
+
+	accountId := d.EqualsQuals["quicksight_account_id"].GetStringValue()
+	// Get AWS Account ID
+	commonData, err := getCommonColumns(ctx, d, h)
+	if err != nil {
+		return nil, err
+	}
+	commonColumnData := commonData.(*awsCommonColumnData)
+
+	if accountId == "" {
+		accountId = commonColumnData.AccountId
+	}
+
+	// Limiting the results
+	maxLimit := int32(100)
+	if d.QueryContext.Limit != nil {
+		limit := int32(*d.QueryContext.Limit)
+		if limit < maxLimit {
+			maxLimit = limit
+		}
+	}
+
+	input := &quicksight.ListDataSourcesInput{
+		AwsAccountId: aws.String(accountId),
+		MaxResults:   aws.Int32(maxLimit),
+	}
+
+	paginator := quicksight.NewListDataSourcesPaginator(svc, input, func(o *quicksight.ListDataSourcesPaginatorOptions) {
+		o.Limit = maxLimit
+		o.StopOnDuplicateToken = true
+	})
+
+	// List call
+	for paginator.HasMorePages() {
+		// apply rate limiting
+		d.WaitForListRateLimit(ctx)
+
+		output, err := paginator.NextPage(ctx)
+		if err != nil {
+			plugin.Logger(ctx).Error("aws_quicksight_data_source.listAwsQuickSightDatasources", "api_error", err)
+			return nil, err
+		}
+
+		for _, item := range output.DataSources {
+			d.StreamListItem(ctx, item)
+
+			// Context may get cancelled due to manual cancellation or if the limit has been reached
+			if d.RowsRemaining(ctx) == 0 {
+				return nil, nil
+			}
+		}
+	}
+
+	return nil, nil
+}
+
+//// HYDRATE FUNCTIONS
+
+func getAwsQuickSightDatasource(ctx context.Context, d *plugin.QueryData, h *plugin.HydrateData) (interface{}, error) {
+	// Create client
+	svc, err := QuickSightClient(ctx, d)
+	if err != nil {
+		plugin.Logger(ctx).Error("aws_quicksight_data_source.getAwsQuickSightDatasource", "connection_error", err)
+		return nil, err
+	}
+
+	var dataSourceID string
+	if h.Item != nil {
+		dataSourceID = *h.Item.(types.DataSource).DataSourceId
+	} else {
+		dataSourceID = d.EqualsQuals["data_source_id"].GetStringValue()
+	}
+
+	accountId := d.EqualsQuals["quicksight_account_id"].GetStringValue()
+
+	// Get AWS Account ID
+	commonData, err := getCommonColumns(ctx, d, h)
+	if err != nil {
+		return nil, err
+	}
+	commonColumnData := commonData.(*awsCommonColumnData)
+
+	if accountId == "" {
+		accountId = commonColumnData.AccountId
+	}
+
+	// Build the params
+	params := &quicksight.DescribeDataSourceInput{
+		AwsAccountId: aws.String(accountId),
+		DataSourceId: aws.String(dataSourceID),
+	}
+
+	// Get call
+	data, err := svc.DescribeDataSource(ctx, params)
+	if err != nil {
+		plugin.Logger(ctx).Error("aws_quicksight_data_source.getAwsQuickSightDatasource", "api_error", err)
+		return nil, err
+	}
+
+	return *data.DataSource, nil
+}
diff --git a/aws/table_aws_quicksight_group.go b/aws/table_aws_quicksight_group.go
new file mode 100644
index 000000000..ca9991068
--- /dev/null
+++ b/aws/table_aws_quicksight_group.go
@@ -0,0 +1,276 @@
+package aws
+
+import (
+	"context"
+	"errors"
+
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/quicksight"
+	"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
+	"github.com/aws/smithy-go"
+
+	"github.com/turbot/steampipe-plugin-sdk/v5/grpc/proto"
+	"github.com/turbot/steampipe-plugin-sdk/v5/plugin"
+	"github.com/turbot/steampipe-plugin-sdk/v5/plugin/transform"
+)
+
+//// TABLE DEFINITION
+
+func tableAwsQuickSightGroup(_ context.Context) *plugin.Table {
+	return &plugin.Table{
+		Name:        "aws_quicksight_group",
+		Description: "AWS QuickSight Group",
+		Get: &plugin.GetConfig{
+			KeyColumns: []*plugin.KeyColumn{
+				{Name:    "group_name", Require: plugin.Required},
+				{Name:    "region", Require: plugin.Required},
+				{Name:    "namespace", Require: plugin.Required},
+				{Name:    "quicksight_account_id", Require: plugin.Optional},
+			},
+			Hydrate: getAwsQuickSightGroup,
+			Tags:    map[string]string{"service": "quicksight", "action": "DescribeGroup"},
+			IgnoreConfig: &plugin.IgnoreConfig{
+				ShouldIgnoreErrorFunc: shouldIgnoreErrors([]string{"ResourceNotFoundException"}),
+			},
+		},
+		List: &plugin.ListConfig{
+			ParentHydrate: listAwsQuickSightNamespaces,
+			Hydrate:       listAwsQuickSightGroups,
+			Tags:          map[string]string{"service": "quicksight", "action": "ListGroups"},
+			KeyColumns: []*plugin.KeyColumn{
+				{Name: "quicksight_account_id", Require: plugin.Optional},
+				{Name: "namespace", Require: plugin.Optional},
+				{Name: "region", Require: plugin.Required},
+			},
+		},
+		GetMatrixItemFunc: SupportedRegionMatrix(AWS_QUICKSIGHT_SERVICE_ID),
+		Columns: awsRegionalColumns([]*plugin.Column{
+			{
+				Name:        "group_name",
+				Description: "The name of the group.",
+				Type:        proto.ColumnType_STRING,
+			},
+			{
+				Name:        "arn",
+				Description: "The Amazon Resource Name (ARN) for the group.",
+				Type:        proto.ColumnType_STRING,
+			},
+			// As we have already a column "account_id" as a common column for all the tables, we have renamed the column to "quicksight_account_id"
+			{
+				Name:        "quicksight_account_id",
+				Description: "The ID for the Amazon Web Services account that the group is in. Currently, you use the ID for the Amazon Web Services account that contains your Amazon QuickSight account.",
+				Type:        proto.ColumnType_STRING,
+				Transform:   transform.FromQual("quicksight_account_id"),
+			},
+			{
+				Name:        "description",
+				Description: "The group description.",
+				Type:        proto.ColumnType_STRING,
+			},
+			{
+				Name:        "principal_id",
+				Description: "The principal ID of the group.",
+				Type:        proto.ColumnType_STRING,
+			},
+			{
+				Name:        "namespace",
+				Description: "The namespace. Currently, you should set this to default.",
+				Type:        proto.ColumnType_STRING,
+			},
+			{
+				Name:        "group_members",
+				Description: "The members of the group.",
+				Type:        proto.ColumnType_JSON,
+				Hydrate:     getAwsQuickSightGroupMembers,
+				Transform:   transform.FromValue(),
+			},
+
+			// Steampipe Standard columns
+			{
+				Name:        "title",
+				Description: resourceInterfaceDescription("title"),
+				Type:        proto.ColumnType_STRING,
+				Transform:   transform.FromField("GroupName"),
+			},
+		}),
+	}
+}
+
+type QuickSightGroup struct {
+	types.Group
+	Namespace string
+}
+
+//// LIST FUNCTION
+
+func listAwsQuickSightGroups(ctx context.Context, d *plugin.QueryData, h *plugin.HydrateData) (interface{}, error) {
+	// Create client
+	svc, err := QuickSightClient(ctx, d)
+	if err != nil {
+		plugin.Logger(ctx).Error("aws_quicksight_group.listAwsQuickSightGroups", "connection_error", err)
+		return nil, err
+	}
+
+	// Get namespace from parent or quals
+	namespaceInfo := h.Item.(types.NamespaceInfoV2)
+	if d.EqualsQuals["namespace"] != nil && d.EqualsQuals["namespace"].GetStringValue() != *namespaceInfo.Name {
+		return nil, nil
+	}
+
+	accountId := d.EqualsQuals["quicksight_account_id"].GetStringValue()
+	// Get AWS Account ID
+	commonData, err := getCommonColumns(ctx, d, h)
+	if err != nil {
+		return nil, err
+	}
+	commonColumnData := commonData.(*awsCommonColumnData)
+
+	if accountId == "" {
+		accountId = commonColumnData.AccountId
+	}
+
+	// Limiting the results
+	maxLimit := int32(100)
+	if d.QueryContext.Limit != nil {
+		limit := int32(*d.QueryContext.Limit)
+		if limit < maxLimit {
+			maxLimit = limit
+		}
+	}
+
+	input := &quicksight.ListGroupsInput{
+		AwsAccountId: aws.String(accountId),
+		Namespace:    namespaceInfo.Name,
+		MaxResults:   aws.Int32(maxLimit),
+	}
+
+	paginator := quicksight.NewListGroupsPaginator(svc, input, func(o *quicksight.ListGroupsPaginatorOptions) {
+		o.Limit = maxLimit
+		o.StopOnDuplicateToken = true
+	})
+
+	// List call
+	for paginator.HasMorePages() {
+		// apply rate limiting
+		d.WaitForListRateLimit(ctx)
+
+		output, err := paginator.NextPage(ctx)
+		if err != nil {
+			//In the case of parent hydrate use the ignore config is not working as expected in the list config.
+			//So we are using this workaround to ignore the ResourceNotFoundException
+			var ae smithy.APIError
+			if errors.As(err, &ae) {
+				if ae.ErrorCode() == "ResourceNotFoundException" {
+					return nil, nil
+				}
+			}
+			plugin.Logger(ctx).Error("aws_quicksight_group.listAwsQuickSightGroups", "api_error", err)
+			return nil, err
+		}
+
+		for _, item := range output.GroupList {
+			d.StreamListItem(ctx, QuickSightGroup{Group: item, Namespace: *namespaceInfo.Name})
+
+			// Context may get cancelled due to manual cancellation or if the limit has been reached
+			if d.RowsRemaining(ctx) == 0 {
+				return nil, nil
+			}
+		}
+	}
+
+	return nil, nil
+}
+
+//// HYDRATE FUNCTIONS
+
+func getAwsQuickSightGroup(ctx context.Context, d *plugin.QueryData, h *plugin.HydrateData) (interface{}, error) {
+	// Create client
+	svc, err := QuickSightClient(ctx, d)
+	if err != nil {
+		plugin.Logger(ctx).Error("aws_quicksight_group.getAwsQuickSightGroup", "connection_error", err)
+		return nil, err
+	}
+
+	groupName := d.EqualsQuals["group_name"].GetStringValue()
+	namespace := d.EqualsQuals["namespace"].GetStringValue()
+
+	// Empty check for required parameters
+	if groupName == "" || namespace == "" {
+		return nil, nil
+	}
+
+	accountId := d.EqualsQuals["quicksight_account_id"].GetStringValue()
+
+	// Get AWS Account ID
+	commonData, err := getCommonColumns(ctx, d, h)
+	if err != nil {
+		return nil, err
+	}
+	commonColumnData := commonData.(*awsCommonColumnData)
+
+	if accountId == "" {
+		accountId = commonColumnData.AccountId
+	}
+
+	params := &quicksight.DescribeGroupInput{
+		AwsAccountId: aws.String(accountId),
+		Namespace:    aws.String(namespace),
+		GroupName:    aws.String(groupName),
+	}
+
+	// Get call
+	data, err := svc.DescribeGroup(ctx, params)
+	if err != nil {
+		plugin.Logger(ctx).Error("aws_quicksight_group.getAwsQuickSightGroup", "api_error", err)
+		return nil, err
+	}
+
+	return QuickSightGroup{Group: *data.Group, Namespace: namespace}, nil
+}
+
+func getAwsQuickSightGroupMembers(ctx context.Context, d *plugin.QueryData, h *plugin.HydrateData) (interface{}, error) {
+	group := h.Item.(QuickSightGroup)
+
+	// Create client
+	svc, err := QuickSightClient(ctx, d)
+	if err != nil {
+		plugin.Logger(ctx).Error("aws_quicksight_group.getAwsQuickSightGroupMembers", "connection_error", err)
+		return nil, err
+	}
+
+	accountId := d.EqualsQuals["quicksight_account_id"].GetStringValue()
+	// Get AWS Account ID
+	commonData, err := getCommonColumns(ctx, d, h)
+	if err != nil {
+		return nil, err
+	}
+	commonColumnData := commonData.(*awsCommonColumnData)
+
+	if accountId == "" {
+		accountId = commonColumnData.AccountId
+	}
+
+	params := &quicksight.ListGroupMembershipsInput{
+		AwsAccountId: aws.String(accountId),
+		Namespace:    aws.String(group.Namespace),
+		GroupName:    group.GroupName,
+	}
+
+	// Get call
+	paginator := quicksight.NewListGroupMembershipsPaginator(svc, params, func(o *quicksight.ListGroupMembershipsPaginatorOptions) {
+		o.Limit = int32(100)
+		o.StopOnDuplicateToken = true
+	})
+
+	var data []types.GroupMember
+	for paginator.HasMorePages() {
+		output, err := paginator.NextPage(ctx)
+		if err != nil {
+			plugin.Logger(ctx).Error("aws_quicksight_group.getAwsQuickSightGroupMembers", "api_error", err)
+			return nil, err
+		}
+		data = append(data, output.GroupMemberList...)
+	}
+
+	return data, nil
+}
diff --git a/aws/table_aws_quicksight_namespace.go b/aws/table_aws_quicksight_namespace.go
new file mode 100644
index 000000000..f73cda653
--- /dev/null
+++ b/aws/table_aws_quicksight_namespace.go
@@ -0,0 +1,205 @@
+package aws
+
+import (
+	"context"
+
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/quicksight"
+
+	"github.com/turbot/steampipe-plugin-sdk/v5/grpc/proto"
+	"github.com/turbot/steampipe-plugin-sdk/v5/plugin"
+	"github.com/turbot/steampipe-plugin-sdk/v5/plugin/transform"
+)
+
+//// TABLE DEFINITION
+
+func tableAwsQuickSightNamespace(_ context.Context) *plugin.Table {
+	return &plugin.Table{
+		Name:        "aws_quicksight_namespace",
+		Description: "AWS QuickSight Namespace",
+		Get: &plugin.GetConfig{
+			KeyColumns: []*plugin.KeyColumn{
+				{Name: "name", Require: plugin.Required},
+				{Name: "quicksight_account_id", Require: plugin.Optional},
+			},
+			Hydrate: getAwsQuickSightNamespace,
+			Tags:    map[string]string{"service": "quicksight", "action": "DescribeNamespace"},
+			IgnoreConfig: &plugin.IgnoreConfig{
+				ShouldIgnoreErrorFunc: shouldIgnoreErrors([]string{"ResourceNotFoundException"}),
+			},
+		},
+		List: &plugin.ListConfig{
+			Hydrate: listAwsQuickSightNamespaces,
+			KeyColumns: []*plugin.KeyColumn{
+				// Namespaces can only be created in the QuickSight identity region.
+				// When listing namespaces from other regions, the API returns the same results,
+				// which can lead to duplicate entries.
+				// Simply requiring the "region" as a qualifier still allows incorrect results to be returned.
+				//
+				// Example: For the query "SELECT * FROM aws_quicksight_namespace WHERE region = 'us-east-1';"
+				// (where 'us-east-1' is a non-identity region), the API still returns namespaces that exist in the identity region, in my case identity region is "ap-south-1".
+				//
+				// Instead, we’ve added a check in the list function to return results only when the queried region
+				// matches the QuickSight capacity (identity) region.
+				{Name: "quicksight_account_id", Require: plugin.Optional},
+			},
+			Tags: map[string]string{"service": "quicksight", "action": "ListNamespaces"},
+		},
+		GetMatrixItemFunc: SupportedRegionMatrix(AWS_QUICKSIGHT_SERVICE_ID),
+		Columns: awsRegionalColumns([]*plugin.Column{
+			{
+				Name:        "name",
+				Description: "The name of the namespace.",
+				Type:        proto.ColumnType_STRING,
+			},
+			{
+				Name:        "arn",
+				Description: "The Amazon Resource Name (ARN) of the namespace.",
+				Type:        proto.ColumnType_STRING,
+			},
+			// As we have already a column "account_id" as a common column for all the tables, we have renamed the column to "quicksight_account_id"
+			{
+				Name:        "quicksight_account_id",
+				Description: "The ID for the Amazon Web Services account that contains the Amazon QuickSight namespace that you want to describe.",
+				Type:        proto.ColumnType_STRING,
+				Transform:   transform.FromQual("quicksight_account_id"),
+			},
+			{
+				Name:        "capacity_region",
+				Description: "The region that hosts the namespace's capacity.",
+				Type:        proto.ColumnType_STRING,
+			},
+			{
+				Name:        "creation_status",
+				Description: "The creation status of the namespace.",
+				Type:        proto.ColumnType_STRING,
+			},
+			{
+				Name:        "identity_store",
+				Description: "The identity store used for the namespace.",
+				Type:        proto.ColumnType_STRING,
+			},
+			{
+				Name:        "namespace_error",
+				Description: "The error type and message for a namespace error.",
+				Type:        proto.ColumnType_JSON,
+			},
+
+			// Steampipe Standard columns
+			{
+				Name:        "title",
+				Description: resourceInterfaceDescription("title"),
+				Type:        proto.ColumnType_STRING,
+				Transform:   transform.FromField("Name"),
+			},
+		}),
+	}
+}
+
+//// LIST FUNCTION
+
+func listAwsQuickSightNamespaces(ctx context.Context, d *plugin.QueryData, h *plugin.HydrateData) (interface{}, error) {
+	// Create client
+	svc, err := QuickSightClient(ctx, d)
+	if err != nil {
+		plugin.Logger(ctx).Error("aws_quicksight_namespace.listAwsQuickSightNamespaces", "connection_error", err)
+		return nil, err
+	}
+
+	accountId := d.EqualsQuals["quicksight_account_id"].GetStringValue()
+	// Get AWS Account ID
+	commonData, err := getCommonColumns(ctx, d, h)
+	if err != nil {
+		return nil, err
+	}
+	commonColumnData := commonData.(*awsCommonColumnData)
+
+	if accountId == "" {
+		accountId = commonColumnData.AccountId
+	}
+
+	// Limiting the results
+	maxLimit := int32(100)
+	if d.QueryContext.Limit != nil {
+		limit := int32(*d.QueryContext.Limit)
+		if limit < maxLimit {
+			maxLimit = limit
+		}
+	}
+
+	input := &quicksight.ListNamespacesInput{
+		AwsAccountId: aws.String(accountId),
+		MaxResults:   aws.Int32(maxLimit),
+	}
+
+	paginator := quicksight.NewListNamespacesPaginator(svc, input, func(o *quicksight.ListNamespacesPaginatorOptions) {
+		o.Limit = maxLimit
+		o.StopOnDuplicateToken = true
+	})
+
+	// List call
+	for paginator.HasMorePages() {
+		// apply rate limiting
+		d.WaitForListRateLimit(ctx)
+
+		output, err := paginator.NextPage(ctx)
+		if err != nil {
+			plugin.Logger(ctx).Error("aws_quicksight_namespace.listAwsQuickSightNamespaces", "api_error", err)
+			return nil, err
+		}
+
+		for _, item := range output.Namespaces {
+			// The API returns the same result regardless of the region.
+			// Adding a check for the capacity region helps prevent duplicate entries.
+			if d.EqualsQuals[matrixKeyRegion].GetStringValue() == *item.CapacityRegion {
+				d.StreamListItem(ctx, item)
+
+				// Context may get cancelled due to manual cancellation or if the limit has been reached
+				if d.RowsRemaining(ctx) == 0 {
+					return nil, nil
+				}
+			}
+		}
+	}
+
+	return nil, nil
+}
+
+//// HYDRATE FUNCTIONS
+
+func getAwsQuickSightNamespace(ctx context.Context, d *plugin.QueryData, h *plugin.HydrateData) (interface{}, error) {
+	// Create client
+	svc, err := QuickSightClient(ctx, d)
+	if err != nil {
+		plugin.Logger(ctx).Error("aws_quicksight_namespace.getAwsQuickSightNamespace", "connection_error", err)
+		return nil, err
+	}
+
+	namespaceName := d.EqualsQuals["name"].GetStringValue()
+
+	accountId := d.EqualsQuals["quicksight_account_id"].GetStringValue()
+	// Get AWS Account ID
+	commonData, err := getCommonColumns(ctx, d, h)
+	if err != nil {
+		return nil, err
+	}
+	commonColumnData := commonData.(*awsCommonColumnData)
+
+	if accountId == "" {
+		accountId = commonColumnData.AccountId
+	}
+
+	params := &quicksight.DescribeNamespaceInput{
+		AwsAccountId: aws.String(accountId),
+		Namespace:    aws.String(namespaceName),
+	}
+
+	// Get call
+	data, err := svc.DescribeNamespace(ctx, params)
+	if err != nil {
+		plugin.Logger(ctx).Error("aws_quicksight_namespace.getAwsQuickSightNamespace", "api_error", err)
+		return nil, err
+	}
+
+	return *data.Namespace, nil
+}
diff --git a/aws/table_aws_quicksight_user.go b/aws/table_aws_quicksight_user.go
new file mode 100644
index 000000000..e0e8a7ef1
--- /dev/null
+++ b/aws/table_aws_quicksight_user.go
@@ -0,0 +1,244 @@
+package aws
+
+import (
+	"context"
+
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/quicksight"
+	"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
+
+	"github.com/turbot/steampipe-plugin-sdk/v5/grpc/proto"
+	"github.com/turbot/steampipe-plugin-sdk/v5/plugin"
+	"github.com/turbot/steampipe-plugin-sdk/v5/plugin/transform"
+)
+
+//// TABLE DEFINITION
+
+func tableAwsQuickSightUser(_ context.Context) *plugin.Table {
+	return &plugin.Table{
+		Name:        "aws_quicksight_user",
+		Description: "AWS QuickSight User",
+		Get: &plugin.GetConfig{
+			KeyColumns: []*plugin.KeyColumn{
+				{Name: "user_name", Require: plugin.Required},
+				{Name: "namespace", Require: plugin.Required},
+				{Name: "region", Require: plugin.Required},
+				{Name: "quicksight_account_id", Require: plugin.Optional},
+			},
+			Hydrate: getAwsQuickSightUser,
+			Tags:    map[string]string{"service": "quicksight", "action": "DescribeUser"},
+			IgnoreConfig: &plugin.IgnoreConfig{
+				ShouldIgnoreErrorFunc: shouldIgnoreErrors([]string{"ResourceNotFoundException"}),
+			},
+		},
+		List: &plugin.ListConfig{
+			ParentHydrate: listAwsQuickSightNamespaces,
+			Hydrate:       listAwsQuickSightUsers,
+			Tags:          map[string]string{"service": "quicksight", "action": "ListUsers"},
+			KeyColumns: []*plugin.KeyColumn{
+				{Name: "quicksight_account_id", Require: plugin.Optional},
+				{Name: "namespace", Require: plugin.Optional},
+				{Name: "region", Require: plugin.Required},
+			},
+			IgnoreConfig: &plugin.IgnoreConfig{
+				ShouldIgnoreErrorFunc: shouldIgnoreErrors([]string{"ResourceNotFoundException"}),
+			},
+		},
+		GetMatrixItemFunc: SupportedRegionMatrix(AWS_QUICKSIGHT_SERVICE_ID),
+		Columns: awsRegionalColumns([]*plugin.Column{
+			{
+				Name:        "user_name",
+				Description: "The user's user name.",
+				Type:        proto.ColumnType_STRING,
+			},
+			{
+				Name:        "arn",
+				Description: "The Amazon Resource Name (ARN) for the user.",
+				Type:        proto.ColumnType_STRING,
+			},
+			// As we have already a column "account_id" as a common column for all the tables, we have renamed the column to "quicksight_account_id"
+			{
+				Name:        "quicksight_account_id",
+				Description: "The ID for the Amazon Web Services account that the user is in. Currently, you use the ID for the Amazon Web Services account that contains your Amazon QuickSight account.",
+				Type:        proto.ColumnType_STRING,
+				Transform:   transform.FromQual("quicksight_account_id"),
+			},
+			{
+				Name:        "email",
+				Description: "The user's email address.",
+				Type:        proto.ColumnType_STRING,
+			},
+			{
+				Name:        "role",
+				Description: "The user's role.",
+				Type:        proto.ColumnType_STRING,
+			},
+			{
+				Name:        "identity_type",
+				Description: "The type of identity authentication used by the user.",
+				Type:        proto.ColumnType_STRING,
+			},
+			{
+				Name:        "active",
+				Description: "The active status of the user. When you create an Amazon QuickSight user that's not an IAM user or an Active Directory user, that user is inactive until they sign in and provide a password.",
+				Type:        proto.ColumnType_BOOL,
+			},
+			{
+				Name:        "principal_id",
+				Description: "The principal ID of the user.",
+				Type:        proto.ColumnType_STRING,
+			},
+			{
+				Name:        "external_login_id",
+				Description: "The identity ID for the user in the external login provider.",
+				Type:        proto.ColumnType_STRING,
+			},
+			{
+				Name:        "namespace",
+				Description: "The namespace. Currently, you should set this to default.",
+				Type:        proto.ColumnType_STRING,
+			},
+			{
+				Name:        "custom_permissions_name",
+				Description: "The custom permissions profile associated with this user.",
+				Type:        proto.ColumnType_STRING,
+			},
+			{
+				Name:        "external_login_federation_provider_type",
+				Description: "The type of supported external login provider that provides identity to let a user federate into Amazon QuickSight with an associated AWS Identity and Access Management (IAM) role.",
+				Type:        proto.ColumnType_STRING,
+			},
+			{
+				Name:        "external_login_federation_provider_url",
+				Description: "The URL of the external login provider.",
+				Type:        proto.ColumnType_STRING,
+			},
+
+			// Steampipe Standard columns
+			{
+				Name:        "title",
+				Description: resourceInterfaceDescription("title"),
+				Type:        proto.ColumnType_STRING,
+				Transform:   transform.FromField("UserName"),
+			},
+		}),
+	}
+}
+
+type QuickSightUser struct {
+	types.User
+	Namespace string
+}
+
+//// LIST FUNCTION
+
+func listAwsQuickSightUsers(ctx context.Context, d *plugin.QueryData, h *plugin.HydrateData) (interface{}, error) {
+	// Create client
+	svc, err := QuickSightClient(ctx, d)
+	if err != nil {
+		plugin.Logger(ctx).Error("aws_quicksight_user.listAwsQuickSightUsers", "connection_error", err)
+		return nil, err
+	}
+
+	// Get namespace from parent or quals
+	namespaceInfo := h.Item.(types.NamespaceInfoV2)
+	if d.EqualsQuals["namespace"] != nil && d.EqualsQuals["namespace"].GetStringValue() != *namespaceInfo.Name {
+		return nil, nil
+	}
+
+	accountId := d.EqualsQuals["quicksight_account_id"].GetStringValue()
+	// Get AWS Account ID
+	commonData, err := getCommonColumns(ctx, d, h)
+	if err != nil {
+		return nil, err
+	}
+	commonColumnData := commonData.(*awsCommonColumnData)
+
+	if accountId == "" {
+		accountId = commonColumnData.AccountId
+	}
+
+	// Limiting the results
+	maxLimit := int32(100)
+	if d.QueryContext.Limit != nil {
+		limit := int32(*d.QueryContext.Limit)
+		if limit < maxLimit {
+			maxLimit = limit
+		}
+	}
+
+	input := &quicksight.ListUsersInput{
+		AwsAccountId: aws.String(accountId),
+		Namespace:    namespaceInfo.Name,
+		MaxResults:   aws.Int32(maxLimit),
+	}
+
+	paginator := quicksight.NewListUsersPaginator(svc, input, func(o *quicksight.ListUsersPaginatorOptions) {
+		o.Limit = maxLimit
+		o.StopOnDuplicateToken = true
+	})
+
+	// List call
+	for paginator.HasMorePages() {
+		// apply rate limiting
+		d.WaitForListRateLimit(ctx)
+
+		output, err := paginator.NextPage(ctx)
+		if err != nil {
+			plugin.Logger(ctx).Error("aws_quicksight_user.listAwsQuickSightUsers", "api_error", err)
+			return nil, err
+		}
+
+		for _, item := range output.UserList {
+			d.StreamListItem(ctx, QuickSightUser{User: item, Namespace: *namespaceInfo.Name})
+
+			// Context may get cancelled due to manual cancellation or if the limit has been reached
+			if d.RowsRemaining(ctx) == 0 {
+				return nil, nil
+			}
+		}
+	}
+
+	return nil, nil
+}
+
+//// HYDRATE FUNCTIONS
+
+func getAwsQuickSightUser(ctx context.Context, d *plugin.QueryData, h *plugin.HydrateData) (interface{}, error) {
+	// Create client
+	svc, err := QuickSightClient(ctx, d)
+	if err != nil {
+		plugin.Logger(ctx).Error("aws_quicksight_user.getAwsQuickSightUser", "connection_error", err)
+		return nil, err
+	}
+
+	userName := d.EqualsQuals["user_name"].GetStringValue()
+	namespace := d.EqualsQuals["namespace"].GetStringValue()
+
+	accountId := d.EqualsQuals["quicksight_account_id"].GetStringValue()
+	// Get AWS Account ID
+	commonData, err := getCommonColumns(ctx, d, h)
+	if err != nil {
+		return nil, err
+	}
+	commonColumnData := commonData.(*awsCommonColumnData)
+
+	if accountId == "" {
+		accountId = commonColumnData.AccountId
+	}
+
+	params := &quicksight.DescribeUserInput{
+		AwsAccountId: aws.String(accountId),
+		Namespace:    aws.String(namespace),
+		UserName:     aws.String(userName),
+	}
+
+	// Get call
+	data, err := svc.DescribeUser(ctx, params)
+	if err != nil {
+		plugin.Logger(ctx).Error("aws_quicksight_user.getAwsQuickSightUser", "api_error", err)
+		return nil, err
+	}
+
+	return QuickSightUser{User: *data.User, Namespace: namespace}, nil
+}
diff --git a/aws/table_aws_quicksight_vpc_connection.go b/aws/table_aws_quicksight_vpc_connection.go
new file mode 100644
index 000000000..f2eece871
--- /dev/null
+++ b/aws/table_aws_quicksight_vpc_connection.go
@@ -0,0 +1,230 @@
+package aws
+
+import (
+	"context"
+
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/quicksight"
+	"github.com/aws/aws-sdk-go-v2/service/quicksight/types"
+
+	"github.com/turbot/steampipe-plugin-sdk/v5/grpc/proto"
+	"github.com/turbot/steampipe-plugin-sdk/v5/plugin"
+	"github.com/turbot/steampipe-plugin-sdk/v5/plugin/transform"
+)
+
+//// TABLE DEFINITION
+
+func tableAwsQuickSightVpcConnection(_ context.Context) *plugin.Table {
+	return &plugin.Table{
+		Name:        "aws_quicksight_vpc_connection",
+		Description: "AWS QuickSight VPC Connection",
+		Get: &plugin.GetConfig{
+			KeyColumns: []*plugin.KeyColumn{
+				{Name: "vpc_connection_id", Require: plugin.Required},
+				{Name: "quicksight_account_id", Require: plugin.Optional},
+			},
+			Hydrate: getAwsQuickSightVpcConnection,
+			Tags:    map[string]string{"service": "quicksight", "action": "DescribeVPCConnection"},
+			IgnoreConfig: &plugin.IgnoreConfig{
+				ShouldIgnoreErrorFunc: shouldIgnoreErrors([]string{"ResourceNotFoundException"}),
+			},
+		},
+		List: &plugin.ListConfig{
+			Hydrate: listAwsQuickSightVpcConnections,
+			KeyColumns: []*plugin.KeyColumn{
+				{Name: "quicksight_account_id", Require: plugin.Optional},
+			},
+			Tags: map[string]string{"service": "quicksight", "action": "ListVPCConnections"},
+		},
+		GetMatrixItemFunc: SupportedRegionMatrix(AWS_QUICKSIGHT_SERVICE_ID),
+		Columns: awsRegionalColumns([]*plugin.Column{
+			{
+				Name:        "name",
+				Description: "A display name for the VPC connection.",
+				Type:        proto.ColumnType_STRING,
+			},
+			{
+				Name:        "vpc_connection_id",
+				Description: "The ID of the VPC connection.",
+				Type:        proto.ColumnType_STRING,
+				Transform:   transform.FromField("VPCConnectionId"),
+			},
+			// As we have already a column "account_id" as a common column for all the tables, we have renamed the column to "quicksight_account_id"
+			{
+				Name:        "quicksight_account_id",
+				Description: "The Amazon Web Services account ID where the VPC connection is located.",
+				Type:        proto.ColumnType_STRING,
+				Transform:   transform.FromQual("quicksight_account_id"),
+			},
+			{
+				Name:        "arn",
+				Description: "The Amazon Resource Name (ARN) of the VPC connection.",
+				Type:        proto.ColumnType_STRING,
+			},
+			{
+				Name:        "created_time",
+				Description: "The time that this VPC connection was created.",
+				Type:        proto.ColumnType_TIMESTAMP,
+			},
+			{
+				Name:        "last_updated_time",
+				Description: "The last time that this VPC connection was updated.",
+				Type:        proto.ColumnType_TIMESTAMP,
+			},
+			{
+				Name:        "status",
+				Description: "The status of the VPC connection.",
+				Type:        proto.ColumnType_STRING,
+			},
+			{
+				Name:        "availability_status",
+				Description: "The availability status of the VPC connection.",
+				Type:        proto.ColumnType_STRING,
+			},
+			{
+				Name:        "role_arn",
+				Description: "The ARN of the IAM role used to create the VPC connection.",
+				Type:        proto.ColumnType_STRING,
+			},
+			{
+				Name:        "security_group_ids",
+				Description: "The security group IDs used for the VPC connection.",
+				Type:        proto.ColumnType_JSON,
+			},
+			{
+				Name:        "dns_resolvers",
+				Description: "The DNS resolvers used for the VPC connection.",
+				Type:        proto.ColumnType_JSON,
+			},
+			{
+				Name:        "network_interfaces",
+				Description: "Information about the network interfaces for the VPC connection.",
+				Type:        proto.ColumnType_JSON,
+			},
+			{
+				Name:        "vpc_id",
+				Description: "The ID of the VPC associated with the connection.",
+				Type:        proto.ColumnType_STRING,
+			},
+
+			// Steampipe Standard columns
+			{
+				Name:        "title",
+				Description: resourceInterfaceDescription("title"),
+				Type:        proto.ColumnType_STRING,
+				Transform:   transform.FromField("Name"),
+			},
+		}),
+	}
+}
+
+//// LIST FUNCTION
+
+func listAwsQuickSightVpcConnections(ctx context.Context, d *plugin.QueryData, h *plugin.HydrateData) (interface{}, error) {
+	// Create client
+	svc, err := QuickSightClient(ctx, d)
+	if err != nil {
+		plugin.Logger(ctx).Error("aws_quicksight_vpc_connection.listAwsQuickSightVpcConnections", "connection_error", err)
+		return nil, err
+	}
+
+	accountId := d.EqualsQuals["quicksight_account_id"].GetStringValue()
+	// Get AWS Account ID
+	commonData, err := getCommonColumns(ctx, d, h)
+	if err != nil {
+		return nil, err
+	}
+	commonColumnData := commonData.(*awsCommonColumnData)
+
+	if accountId == "" {
+		accountId = commonColumnData.AccountId
+	}
+
+	// Limiting the results
+	maxLimit := int32(100)
+	if d.QueryContext.Limit != nil {
+		limit := int32(*d.QueryContext.Limit)
+		if limit < maxLimit {
+			maxLimit = limit
+		}
+	}
+
+	input := &quicksight.ListVPCConnectionsInput{
+		AwsAccountId: aws.String(accountId),
+		MaxResults:   aws.Int32(maxLimit),
+	}
+
+	paginator := quicksight.NewListVPCConnectionsPaginator(svc, input, func(o *quicksight.ListVPCConnectionsPaginatorOptions) {
+		o.Limit = maxLimit
+		o.StopOnDuplicateToken = true
+	})
+
+	// List call
+	for paginator.HasMorePages() {
+		// apply rate limiting
+		d.WaitForListRateLimit(ctx)
+
+		output, err := paginator.NextPage(ctx)
+		if err != nil {
+			plugin.Logger(ctx).Error("aws_quicksight_vpc_connection.listAwsQuickSightVpcConnections", "api_error", err)
+			return nil, err
+		}
+
+		for _, item := range output.VPCConnectionSummaries {
+			d.StreamListItem(ctx, item)
+
+			// Context may get cancelled due to manual cancellation or if the limit has been reached
+			if d.RowsRemaining(ctx) == 0 {
+				return nil, nil
+			}
+		}
+	}
+
+	return nil, nil
+}
+
+//// HYDRATE FUNCTIONS
+
+func getAwsQuickSightVpcConnection(ctx context.Context, d *plugin.QueryData, h *plugin.HydrateData) (interface{}, error) {
+	// Create client
+	svc, err := QuickSightClient(ctx, d)
+	if err != nil {
+		plugin.Logger(ctx).Error("aws_quicksight_vpc_connection.getAwsQuickSightVpcConnection", "connection_error", err)
+		return nil, err
+	}
+
+	var vpcConnectionId string
+	if h.Item != nil {
+		vpcConnectionId = *h.Item.(types.VPCConnectionSummary).VPCConnectionId
+	} else {
+		vpcConnectionId = d.EqualsQuals["vpc_connection_id"].GetStringValue()
+	}
+
+	accountId := d.EqualsQuals["quicksight_account_id"].GetStringValue()
+
+	// Get AWS Account ID
+	commonData, err := getCommonColumns(ctx, d, h)
+	if err != nil {
+		return nil, err
+	}
+	commonColumnData := commonData.(*awsCommonColumnData)
+
+	if accountId == "" {
+		accountId = commonColumnData.AccountId
+	}
+
+	// Build the params
+	params := &quicksight.DescribeVPCConnectionInput{
+		AwsAccountId:    aws.String(accountId),
+		VPCConnectionId: aws.String(vpcConnectionId),
+	}
+
+	// Get call
+	data, err := svc.DescribeVPCConnection(ctx, params)
+	if err != nil {
+		plugin.Logger(ctx).Error("aws_quicksight_vpc_connection.getAwsQuickSightVpcConnection", "api_error", err)
+		return nil, err
+	}
+
+	return *data.VPCConnection, nil
+}
diff --git a/docs/tables/aws_quicksight_account_setting.md b/docs/tables/aws_quicksight_account_setting.md
new file mode 100644
index 000000000..9a2855c1f
--- /dev/null
+++ b/docs/tables/aws_quicksight_account_setting.md
@@ -0,0 +1,137 @@
+---
+title: "Steampipe Table: aws_quicksight_account_setting - Query AWS QuickSight Account Settings using SQL"
+description: "Allows users to query AWS QuickSight Account Settings, providing details about the QuickSight account configuration, edition, notification settings, and security features."
+---
+
+# Table: aws_quicksight_account_setting - Query AWS QuickSight Account Settings using SQL
+
+AWS QuickSight Account Settings represent the configuration and preferences set for your QuickSight account. These settings include account name, edition type, notification email, security features, and various other configurations that determine how QuickSight operates within your AWS environment.
+
+## Table Usage Guide
+
+The `aws_quicksight_account_setting` table in Steampipe provides you with information about account settings within AWS QuickSight. This table allows you, as a data analyst or administrator, to query account-specific details, including edition type, notification settings, security configurations, and various other account-level settings. You can utilize this table to gather insights on account configurations, such as termination protection status, public sharing settings, and notification preferences.
+
+**Important Notes**
+- You **_must_** specify `region` in a `where` clause in order to use this table.
+- Account setting information for QuickSight is only available from the **identity region** (i.e., the region where the QuickSight account was initially created or enabled).
+- Since there is no direct API to retrieve the identity region, users must provide it manually in the query to retrieve data successfully.
+
+## Examples
+
+### Basic info
+Explore the basic configuration of your AWS QuickSight account to understand its setup and security settings.
+
+```sql+postgres
+select
+  account_name,
+  edition,
+  default_namespace,
+  notification_email,
+  termination_protection_enabled,
+  public_sharing_enabled
+from
+  aws_quicksight_account_setting
+where
+  region = 'us-east-1';
+```
+
+```sql+sqlite
+select
+  account_name,
+  edition,
+  default_namespace,
+  notification_email,
+  termination_protection_enabled,
+  public_sharing_enabled
+from
+  aws_quicksight_account_setting
+where
+  region = 'us-east-1';
+```
+
+### Check accounts with termination protection disabled
+Identify AWS QuickSight accounts that might be at risk due to disabled termination protection.
+
+```sql+postgres
+select
+  account_name,
+  edition,
+  notification_email,
+  termination_protection_enabled
+from
+  aws_quicksight_account_setting
+where
+  region = 'us-east-1'
+  and not termination_protection_enabled;
+```
+
+```sql+sqlite
+select
+  account_name,
+  edition,
+  notification_email,
+  termination_protection_enabled
+from
+  aws_quicksight_account_setting
+where
+  region = 'us-east-1'
+  and termination_protection_enabled = 0;
+```
+
+### List accounts with public sharing enabled
+Identify accounts that have public sharing enabled to assess potential data exposure risks.
+
+```sql+postgres
+select
+  account_name,
+  edition,
+  notification_email,
+  public_sharing_enabled
+from
+  aws_quicksight_account_setting
+where
+  region = 'us-east-1'
+  and public_sharing_enabled;
+```
+
+```sql+sqlite
+select
+  account_name,
+  edition,
+  notification_email,
+  public_sharing_enabled
+from
+  aws_quicksight_account_setting
+where
+  region = 'us-east-1'
+  and public_sharing_enabled = 1;
+```
+
+### Get enterprise edition accounts
+List all QuickSight accounts that are using the Enterprise edition to understand feature availability.
+
+```sql+postgres
+select
+  account_name,
+  edition,
+  default_namespace,
+  notification_email
+from
+  aws_quicksight_account_setting
+where
+  region = 'us-east-1'
+  and edition = 'ENTERPRISE';
+```
+
+```sql+sqlite
+select
+  account_name,
+  edition,
+  default_namespace,
+  notification_email
+from
+  aws_quicksight_account_setting
+where
+  region = 'us-east-1'
+  and edition = 'ENTERPRISE';
+```
diff --git a/docs/tables/aws_quicksight_data_set.md b/docs/tables/aws_quicksight_data_set.md
new file mode 100644
index 000000000..df80eee22
--- /dev/null
+++ b/docs/tables/aws_quicksight_data_set.md
@@ -0,0 +1,141 @@
+---
+title: "Steampipe Table: aws_quicksight_data_set - Query AWS QuickSight Datasets using SQL"
+description: "Allows users to query AWS QuickSight Datasets and retrieve information about datasets within AWS QuickSight."
+---
+
+# Table: aws_quicksight_data_set - Query AWS QuickSight Datasets using SQL
+
+AWS QuickSight is a fully managed, serverless business intelligence service that makes it easy to extend the power of machine learning generated insights to everyone in your organization. AWS QuickSight Dataset is a collection of data, either from a single source or from multiple sources. You create a dataset before you can analyze your data.
+
+## Table Usage Guide
+
+The `aws_quicksight_data_set` table in Steampipe provides you with information about datasets within AWS QuickSight. This table allows you, as a data analyst or administrator, to query dataset-specific details, including the data source, import mode, and associated configurations. You can utilize this table to gather insights on datasets, such as dataset structure, associated data sources, import configurations, and more. The schema outlines the various attributes of the QuickSight dataset for you to query, including the dataset ID, ARN, creation time, and associated tags.
+
+## Examples
+
+### Basic info
+Explore which datasets are available in your AWS QuickSight environment and when they were created. This can help you manage and organize your data resources effectively.
+
+```sql+postgres
+select
+  name,
+  dataset_id,
+  created_time,
+  last_updated_time
+from
+  aws_quicksight_data_set;
+```
+
+```sql+sqlite
+select
+  name,
+  dataset_id,
+  created_time,
+  last_updated_time
+from
+  aws_quicksight_data_set;
+```
+
+### List datasets with SPICE import mode
+Identify datasets that use SPICE as their import mode. This is useful for understanding which datasets leverage QuickSight's in-memory calculation engine for faster analysis.
+
+```sql+postgres
+select
+  name,
+  dataset_id,
+  import_mode
+from
+  aws_quicksight_data_set
+where
+  import_mode = 'SPICE';
+```
+
+```sql+sqlite
+select
+  name,
+  dataset_id,
+  import_mode
+from
+  aws_quicksight_data_set
+where
+  import_mode = 'SPICE';
+```
+
+### Find datasets with row-level permissions
+Determine which datasets have row-level permission controls in place. This helps identify datasets with enhanced security controls that restrict user access to specific rows of data.
+
+```sql+postgres
+select
+  name,
+  dataset_id,
+  row_level_permission_data_set
+from
+  aws_quicksight_data_set
+where
+  row_level_permission_data_set is not null;
+```
+
+```sql+sqlite
+select
+  name,
+  dataset_id,
+  row_level_permission_data_set
+from
+  aws_quicksight_data_set
+where
+  row_level_permission_data_set is not null;
+```
+
+### Get datasets with column-level permissions
+Discover datasets that implement column-level permission rules to control access to specific columns of data. This is helpful for assessing security controls across your datasets.
+
+```sql+postgres
+select
+  name,
+  dataset_id,
+  column_level_permission_rules
+from
+  aws_quicksight_data_set
+where
+  column_level_permission_rules is not null;
+```
+
+```sql+sqlite
+select
+  name,
+  dataset_id,
+  column_level_permission_rules
+from
+  aws_quicksight_data_set
+where
+  column_level_permission_rules is not null;
+```
+
+### List datasets created in the last 30 days
+Identify recently created datasets to monitor new data resources or track recent changes to your QuickSight environment.
+
+```sql+postgres
+select
+  name,
+  dataset_id,
+  created_time
+from
+  aws_quicksight_data_set
+where
+  created_time > now() - interval '30 days'
+order by
+  created_time desc;
+```
+
+```sql+sqlite
+select
+  name,
+  dataset_id,
+  created_time
+from
+  aws_quicksight_data_set
+where
+  created_time > datetime('now', '-30 days')
+order by
+  created_time desc;
+```
diff --git a/docs/tables/aws_quicksight_data_source.md b/docs/tables/aws_quicksight_data_source.md
new file mode 100644
index 000000000..c6be084c0
--- /dev/null
+++ b/docs/tables/aws_quicksight_data_source.md
@@ -0,0 +1,174 @@
+---
+title: "Steampipe Table: aws_quicksight_data_source - Query AWS QuickSight Data Sources using SQL"
+description: "Allows users to query AWS QuickSight Data Sources, providing details about data source configurations, connections, and status information."
+---
+
+# Table: aws_quicksight_data_source - Query AWS QuickSight Data Sources using SQL
+
+AWS QuickSight Data Source is a connection to your data that QuickSight uses to create datasets. It contains the connection information, credentials, and other parameters needed to access your data from various sources like Amazon S3, Amazon RDS, or other supported data sources.
+
+## Table Usage Guide
+
+The `aws_quicksight_data_source` table in Steampipe provides you with information about data sources within AWS QuickSight. This table allows you, as a data analyst or administrator, to query data source-specific details, including connection properties, status, and configuration parameters. You can utilize this table to gather insights on data sources, such as their creation time, last update time, connection status, and type.
+
+## Examples
+
+### Basic info
+Explore the fundamental details of your QuickSight data sources to understand their configuration and connection types.
+
+```sql+postgres
+select
+  name,
+  data_source_id,
+  arn,
+  created_time,
+  last_updated_time,
+  status,
+  type
+from
+  aws_quicksight_data_source;
+```
+
+```sql+sqlite
+select
+  name,
+  data_source_id,
+  arn,
+  created_time,
+  last_updated_time,
+  status,
+  type
+from
+  aws_quicksight_data_source;
+```
+
+### List failed data sources
+Identify data sources that have failed to help troubleshoot connection issues.
+
+```sql+postgres
+select
+  name,
+  data_source_id,
+  status,
+  error_info
+from
+  aws_quicksight_data_source
+where
+  status like '%FAILED%';
+```
+
+```sql+sqlite
+select
+  name,
+  data_source_id,
+  status,
+  error_info
+from
+  aws_quicksight_data_source
+where
+  status like '%FAILED%';
+```
+
+### Get S3 data sources
+Analyze the configuration of S3-based data sources to understand your data connections.
+
+```sql+postgres
+select
+  name,
+  data_source_id,
+  status,
+  data_source_parameters
+from
+  aws_quicksight_data_source
+where
+  type = 'S3';
+```
+
+```sql+sqlite
+select
+  name,
+  data_source_id,
+  status,
+  data_source_parameters
+from
+  aws_quicksight_data_source
+where
+  type = 'S3';
+```
+
+### List data sources with VPC connections
+Identify data sources that are configured with VPC connections for network security assessment.
+
+```sql+postgres
+select
+  name,
+  data_source_id,
+  vpc_connection_properties
+from
+  aws_quicksight_data_source
+where
+  vpc_connection_properties is not null;
+```
+
+```sql+sqlite
+select
+  name,
+  data_source_id,
+  vpc_connection_properties
+from
+  aws_quicksight_data_source
+where
+  vpc_connection_properties is not null;
+```
+
+### Get data sources with SSL configuration
+Review data sources that have SSL properties configured for secure connections.
+
+```sql+postgres
+select
+  name,
+  data_source_id,
+  ssl_properties
+from
+  aws_quicksight_data_source
+where
+  ssl_properties is not null;
+```
+
+```sql+sqlite
+select
+  name,
+  data_source_id,
+  ssl_properties
+from
+  aws_quicksight_data_source
+where
+  ssl_properties is not null;
+```
+
+### List data sources with alternate parameters
+Find data sources that have alternate connection parameters configured.
+
+```sql+postgres
+select
+  name,
+  data_source_id,
+  type,
+  alternate_data_source_parameters
+from
+  aws_quicksight_data_source
+where
+  alternate_data_source_parameters is not null;
+```
+
+```sql+sqlite
+select
+  name,
+  data_source_id,
+  type,
+  alternate_data_source_parameters
+from
+  aws_quicksight_data_source
+where
+  alternate_data_source_parameters is not null;
+```
diff --git a/docs/tables/aws_quicksight_group.md b/docs/tables/aws_quicksight_group.md
new file mode 100644
index 000000000..62aa9798d
--- /dev/null
+++ b/docs/tables/aws_quicksight_group.md
@@ -0,0 +1,125 @@
+---
+title: "Steampipe Table: aws_quicksight_group - Query AWS QuickSight Groups using SQL"
+description: "Allows users to query AWS QuickSight Groups, providing details about group configurations, memberships, and access settings within QuickSight."
+---
+
+# Table: aws_quicksight_group - Query AWS QuickSight Groups using SQL
+
+AWS QuickSight Group is a collection of users that can be managed together for access control and permission management. Groups help simplify the administration of QuickSight by allowing you to assign permissions to multiple users at once.
+
+## Table Usage Guide
+
+The `aws_quicksight_group` table in Steampipe provides you with information about groups within AWS QuickSight. This table allows you, as an administrator, to query group-specific details, including group names, ARNs, and associated permissions. You can utilize this table to gather insights on group management, such as group memberships, access levels, and namespace associations.
+
+**Important Notes**
+
+- You **_must_** specify `region` in a `where` clause in order to use this table.
+- Group information for QuickSight is only available from the **identity region** (i.e., the region where the QuickSight account was initially created or enabled).
+- Since there is no direct API to retrieve the identity region, users must provide it manually in the query to retrieve data successfully.
+
+## Examples
+
+### Basic info
+Explore the basic details of your QuickSight groups to understand their organization and naming conventions.
+
+```sql+postgres
+select
+  group_name,
+  arn,
+  description,
+  namespace,
+  principal_id
+from
+  aws_quicksight_group
+where
+  region = 'us-east-1';
+```
+
+```sql+sqlite
+select
+  group_name,
+  arn,
+  description,
+  namespace,
+  principal_id
+from
+  aws_quicksight_group
+where
+  region = 'us-east-1';
+```
+
+### List groups for a specific namespace
+Focus on groups within a particular namespace to better manage access and permissions for specific organizational units.
+
+```sql+postgres
+select
+  group_name,
+  arn,
+  description,
+  principal_id
+from
+  aws_quicksight_group
+where
+  region = 'us-east-1'
+  and namespace = 'default';
+```
+
+```sql+sqlite
+select
+  group_name,
+  arn,
+  description,
+  principal_id
+from
+  aws_quicksight_group
+where
+  region = 'us-east-1'
+  and namespace = 'default';
+```
+
+### Get user details for each QuickSight group
+Identify all users belonging to each QuickSight group to understand group memberships and simplify access management.
+
+```sql+postgres
+select
+  g.group_name,
+  g.description,
+  u.user_name,
+  u.email,
+  u.role,
+  u.active
+from
+  aws_quicksight_group g,
+  jsonb_array_elements(g.group_members) as m
+join
+  aws_quicksight_user u
+  on u.arn = (m ->> 'Arn')
+where
+  g.region = 'us-east-1'
+  and u.region = 'us-east-1'
+order by
+  g.group_name,
+  u.user_name;
+```
+
+```sql+sqlite
+select
+  g.group_name,
+  g.description,
+  u.user_name,
+  u.email,
+  u.role,
+  u.active
+from
+  aws_quicksight_group g,
+  json_each(g.group_members) as m
+join
+  aws_quicksight_user u
+  on u.arn = json_extract(m.value, '$.Arn')
+where
+  g.region = 'us-east-1'
+  and u.region = 'us-east-1'
+order by
+  g.group_name,
+  u.user_name;
+```
\ No newline at end of file
diff --git a/docs/tables/aws_quicksight_namespace.md b/docs/tables/aws_quicksight_namespace.md
new file mode 100644
index 000000000..27a153924
--- /dev/null
+++ b/docs/tables/aws_quicksight_namespace.md
@@ -0,0 +1,143 @@
+---
+title: "Steampipe Table: aws_quicksight_namespace - Query AWS QuickSight Namespaces using SQL"
+description: "Allows users to query AWS QuickSight Namespaces, providing details about namespace configurations, identity stores, and status information."
+---
+
+# Table: aws_quicksight_namespace - Query AWS QuickSight Namespaces using SQL
+
+AWS QuickSight Namespace is a logical container that helps organize and manage QuickSight resources. Each namespace can have its own identity store and configuration settings, allowing for better organization and access control of QuickSight resources.
+
+## Table Usage Guide
+
+The `aws_quicksight_namespace` table in Steampipe provides you with information about namespaces within AWS QuickSight. This table allows you, as an administrator, to query namespace-specific details, including identity store configurations and creation status. You can utilize this table to gather insights on namespace management, such as creation status, capacity regions, and associated identity stores.
+
+## Examples
+
+### Basic info
+Explore the fundamental details of your QuickSight namespaces to understand their organization and structure.
+
+```sql+postgres
+select
+  name,
+  arn,
+  capacity_region,
+  creation_status,
+  identity_store
+from
+  aws_quicksight_namespace;
+```
+
+```sql+sqlite
+select
+  name,
+  arn,
+  capacity_region,
+  creation_status,
+  identity_store
+from
+  aws_quicksight_namespace;
+```
+
+### List namespaces with creation errors
+Identify namespaces that encountered errors during creation to troubleshoot issues.
+
+```sql+postgres
+select
+  name,
+  creation_status,
+  namespace_error
+from
+  aws_quicksight_namespace
+where
+  namespace_error is not null;
+```
+
+```sql+sqlite
+select
+  name,
+  creation_status,
+  namespace_error
+from
+  aws_quicksight_namespace
+where
+  namespace_error is not null;
+```
+
+### Get namespaces using IAM Identity Center
+Determine which namespaces are configured to use IAM Identity Center for authentication.
+
+```sql+postgres
+select
+  name,
+  arn,
+  identity_store,
+  creation_status
+from
+  aws_quicksight_namespace
+where
+  identity_store = 'IAM_IDENTITY_CENTER';
+```
+
+```sql+sqlite
+select
+  name,
+  arn,
+  identity_store,
+  creation_status
+from
+  aws_quicksight_namespace
+where
+  identity_store = 'IAM_IDENTITY_CENTER';
+```
+
+### List namespaces by capacity region
+Analyze the distribution of namespaces across different capacity regions.
+
+```sql+postgres
+select
+  capacity_region,
+  count(*) as namespace_count,
+  array_agg(name) as namespaces
+from
+  aws_quicksight_namespace
+group by
+  capacity_region;
+```
+
+```sql+sqlite
+select
+  capacity_region,
+  count(*) as namespace_count,
+  group_concat(name) as namespaces
+from
+  aws_quicksight_namespace
+group by
+  capacity_region;
+```
+
+### Get successfully created namespaces
+List all namespaces that have been successfully created and are ready to use.
+
+```sql+postgres
+select
+  name,
+  arn,
+  identity_store,
+  capacity_region
+from
+  aws_quicksight_namespace
+where
+  creation_status = 'CREATED';
+```
+
+```sql+sqlite
+select
+  name,
+  arn,
+  identity_store,
+  capacity_region
+from
+  aws_quicksight_namespace
+where
+  creation_status = 'CREATED';
+```
diff --git a/docs/tables/aws_quicksight_user.md b/docs/tables/aws_quicksight_user.md
new file mode 100644
index 000000000..41ff5ee46
--- /dev/null
+++ b/docs/tables/aws_quicksight_user.md
@@ -0,0 +1,191 @@
+---
+title: "Steampipe Table: aws_quicksight_user - Query AWS QuickSight Users using SQL"
+description: "Allows users to query AWS QuickSight Users, providing details about user accounts, roles, and access configurations within QuickSight."
+---
+
+# Table: aws_quicksight_user - Query AWS QuickSight Users using SQL
+
+AWS QuickSight User represents an individual account that can access and interact with QuickSight resources. Each user has specific roles and permissions that determine their level of access and capabilities within QuickSight.
+
+## Table Usage Guide
+
+The `aws_quicksight_user` table in Steampipe provides you with information about users within AWS QuickSight. This table allows you, as an administrator, to query user-specific details, including roles, identity types, and access configurations. You can utilize this table to gather insights on user management, such as active status, authentication methods, and permission levels.
+
+**Important Notes**
+- You **_must_** specify `region` in a `where` clause in order to use this table.
+- User information for QuickSight is only available from the **identity region** (i.e., the region where the QuickSight account was initially created or enabled).
+- Since there is no direct API to retrieve the identity region, users must provide it manually in the query to retrieve data successfully.
+
+## Examples
+
+### Basic info
+Explore the basic details of QuickSight users to understand who has access to your QuickSight account.
+
+```sql+postgres
+select
+  user_name,
+  arn,
+  email,
+  role,
+  identity_type,
+  active
+from
+  aws_quicksight_user
+where
+  region = 'us-east-1';
+```
+
+```sql+sqlite
+select
+  user_name,
+  arn,
+  email,
+  role,
+  identity_type,
+  active
+from
+  aws_quicksight_user
+where
+  region = 'us-east-1';
+```
+
+### List admin users
+Identify all QuickSight users who have administrative privileges to manage security and governance.
+
+```sql+postgres
+select
+  user_name,
+  email,
+  role,
+  identity_type
+from
+  aws_quicksight_user
+where
+  region = 'us-east-1'
+  and role = 'ADMIN';
+```
+
+```sql+sqlite
+select
+  user_name,
+  email,
+  role,
+  identity_type
+from
+  aws_quicksight_user
+where
+  region = 'us-east-1'
+  and role = 'ADMIN';
+```
+
+### Find inactive users
+Determine which users are currently inactive to manage access and licenses.
+
+```sql+postgres
+select
+  user_name,
+  email,
+  role,
+  identity_type
+from
+  aws_quicksight_user
+where
+  region = 'us-east-1'
+  and not active;
+```
+
+```sql+sqlite
+select
+  user_name,
+  email,
+  role,
+  identity_type
+from
+  aws_quicksight_user
+where
+  region = 'us-east-1'
+  and active = 0;
+```
+
+### List users by identity type
+Analyze the distribution of users based on their authentication method.
+
+```sql+postgres
+select
+  identity_type,
+  count(*) as user_count
+from
+  aws_quicksight_user
+where
+  region = 'us-east-1'
+group by
+  identity_type;
+```
+
+```sql+sqlite
+select
+  identity_type,
+  count(*) as user_count
+from
+  aws_quicksight_user
+where
+  region = 'us-east-1'
+group by
+  identity_type;
+```
+
+### List users with external login federation
+Discover users who are authenticated via external login federation providers.
+
+```sql+postgres
+select
+  user_name,
+  email,
+  external_login_federation_provider_type,
+  external_login_federation_provider_url
+from
+  aws_quicksight_user
+where
+  region = 'us-east-1'
+  and external_login_federation_provider_type is not null;
+```
+
+```sql+sqlite
+select
+  user_name,
+  email,
+  external_login_federation_provider_type,
+  external_login_federation_provider_url
+from
+  aws_quicksight_user
+where
+  region = 'us-east-1'
+  and external_login_federation_provider_type is not null;
+```
+
+### List users with custom permissions
+Find users who have been assigned custom permission profiles rather than standard roles.
+
+```sql+postgres
+select
+  user_name,
+  email,
+  custom_permissions_name
+from
+  aws_quicksight_user
+where
+  region = 'us-east-1'
+  and custom_permissions_name is not null;
+```
+
+```sql+sqlite
+select
+  user_name,
+  email,
+  custom_permissions_name
+from
+  aws_quicksight_user
+where
+  region = 'us-east-1'
+  and custom_permissions_name is not null;
+```
diff --git a/docs/tables/aws_quicksight_vpc_connection.md b/docs/tables/aws_quicksight_vpc_connection.md
new file mode 100644
index 000000000..443b2ae65
--- /dev/null
+++ b/docs/tables/aws_quicksight_vpc_connection.md
@@ -0,0 +1,138 @@
+---
+title: "Steampipe Table: aws_quicksight_vpc_connection - Query AWS QuickSight VPC Connections using SQL"
+description: "Allows users to query AWS QuickSight VPC Connections to retrieve details about VPC connections used for secure data access."
+---
+
+# Table: aws_quicksight_vpc_connection - Query AWS QuickSight VPC Connections using SQL
+
+AWS QuickSight VPC Connection is a feature that allows you to connect QuickSight to your data sources in a VPC. This connection enables secure access to data sources within your VPC for visualization and analysis in QuickSight. VPC connections help maintain data security by providing a private network connection between QuickSight and your data sources.
+
+## Table Usage Guide
+
+The `aws_quicksight_vpc_connection` table in Steampipe provides you with information about VPC connections within AWS QuickSight. This table allows you, as a data analyst or administrator, to query VPC connection-specific details, including configuration, status, and security settings. You can use this table to gather insights on VPC connections, such as their current status, the VPC and security groups they're connected to, security group configurations, and more. The schema outlines the various attributes of the QuickSight VPC connection for you to query, including the connection ID, ARN, creation time, and associated network details.
+
+## Examples
+
+### Basic info
+Retrieve basic information about QuickSight VPC connections.
+
+```sql+postgres
+select
+  name,
+  vpc_connection_id,
+  status,
+  availability_status,
+  vpc_id
+from
+  aws_quicksight_vpc_connection;
+```
+
+```sql+sqlite
+select
+  name,
+  vpc_connection_id,
+  status,
+  availability_status,
+  vpc_id
+from
+  aws_quicksight_vpc_connection;
+```
+
+### List recently created VPC connections
+Identify VPC connections that were created within the last 30 days.
+
+```sql+postgres
+select
+  name,
+  vpc_connection_id,
+  created_time,
+  status
+from
+  aws_quicksight_vpc_connection
+where
+  created_time > now() - interval '30 days';
+```
+
+```sql+sqlite
+select
+  name,
+  vpc_connection_id,
+  created_time,
+  status
+from
+  aws_quicksight_vpc_connection
+where
+  created_time > datetime('now', '-30 days');
+```
+
+### Get VPC connections with their associated security groups
+Retrieve VPC connections along with their associated security groups for security assessment.
+
+```sql+postgres
+select
+  name,
+  vpc_connection_id,
+  vpc_id,
+  security_group_ids
+from
+  aws_quicksight_vpc_connection;
+```
+
+```sql+sqlite
+select
+  name,
+  vpc_connection_id,
+  vpc_id,
+  security_group_ids
+from
+  aws_quicksight_vpc_connection;
+```
+
+### List VPC connections by availability status
+Group VPC connections by their availability status to understand the current operational state.
+
+```sql+postgres
+select
+  availability_status,
+  count(*) as connection_count
+from
+  aws_quicksight_vpc_connection
+group by
+  availability_status;
+```
+
+```sql+sqlite
+select
+  availability_status,
+  count(*) as connection_count
+from
+  aws_quicksight_vpc_connection
+group by
+  availability_status;
+```
+
+### Find VPC connections with DNS resolvers configured
+Identify VPC connections that have DNS resolvers configured for name resolution.
+
+```sql+postgres
+select
+  name,
+  vpc_connection_id,
+  dns_resolvers
+from
+  aws_quicksight_vpc_connection
+where
+  dns_resolvers is not null
+  and jsonb_array_length(dns_resolvers) > 0;
+```
+
+```sql+sqlite
+select
+  name,
+  vpc_connection_id,
+  dns_resolvers
+from
+  aws_quicksight_vpc_connection
+where
+  dns_resolvers is not null;
+```
diff --git a/go.mod b/go.mod
index 508e990df..6d93d3a39 100644
--- a/go.mod
+++ b/go.mod
@@ -99,6 +99,7 @@ require (
 	github.com/aws/aws-sdk-go-v2/service/pinpoint v1.29.0
 	github.com/aws/aws-sdk-go-v2/service/pipes v1.11.4
 	github.com/aws/aws-sdk-go-v2/service/pricing v1.28.1
+	github.com/aws/aws-sdk-go-v2/service/quicksight v1.64.2
 	github.com/aws/aws-sdk-go-v2/service/ram v1.25.4
 	github.com/aws/aws-sdk-go-v2/service/rds v1.77.0
 	github.com/aws/aws-sdk-go-v2/service/redshift v1.43.5
@@ -136,7 +137,7 @@ require (
 	github.com/aws/aws-sdk-go-v2/service/wafv2 v1.48.2
 	github.com/aws/aws-sdk-go-v2/service/wellarchitected v1.29.4
 	github.com/aws/aws-sdk-go-v2/service/workspaces v1.38.4
-	github.com/aws/smithy-go v1.22.1
+	github.com/aws/smithy-go v1.22.2
 	github.com/gocarina/gocsv v0.0.0-20201208093247-67c824bc04d4
 	github.com/goccy/go-yaml v1.11.3
 	github.com/golang/protobuf v1.5.4
diff --git a/go.sum b/go.sum
index e819b69ba..c422a44d2 100644
--- a/go.sum
+++ b/go.sum
@@ -411,6 +411,8 @@ github.com/aws/aws-sdk-go-v2/service/pipes v1.11.4 h1:xOLwoRZoNFTNeM1W6jafNh9xFm
 github.com/aws/aws-sdk-go-v2/service/pipes v1.11.4/go.mod h1:mvuBjGM/Fc/GbFTF4SNX4BtXg4SX9WwB6r8a2mOztCc=
 github.com/aws/aws-sdk-go-v2/service/pricing v1.28.1 h1:BUaW46SlGFEqknJq82CjFPTI/M7LhiGuZrLf2zowXiY=
 github.com/aws/aws-sdk-go-v2/service/pricing v1.28.1/go.mod h1:nRP1NcPnLcvdtG5z0QFxYKK2UwV7/ZZaAXh4YMGlGMc=
+github.com/aws/aws-sdk-go-v2/service/quicksight v1.64.2 h1:qJ85WPSt8VLAW59GGsqDFCdQB/CbgXK9wnUWuEyvfiA=
+github.com/aws/aws-sdk-go-v2/service/quicksight v1.64.2/go.mod h1:gjmbCte2Tbq1mOgNd4bG4UlbEbba4jyFd6JtZpHuVng=
 github.com/aws/aws-sdk-go-v2/service/ram v1.25.4 h1:jkrrriOy9I7ZpswuT7wzcOvClm5RC7sFJrw/qQTl0cs=
 github.com/aws/aws-sdk-go-v2/service/ram v1.25.4/go.mod h1:ZDVnnA45kEAe24PtJOB3pgU0GdKeoRAJPIDCIVXal9c=
 github.com/aws/aws-sdk-go-v2/service/rds v1.77.0 h1:5U1HvcksSLGJ81tXSDEPYGqkSRxlLcobrMBv8OvuDsY=
@@ -491,8 +493,8 @@ github.com/aws/aws-sdk-go-v2/service/wellarchitected v1.29.4 h1:OuFs453KXWTLBkem
 github.com/aws/aws-sdk-go-v2/service/wellarchitected v1.29.4/go.mod h1:MRT/P9Cwn+7xCCVpD1sTvUESiWMAc9hA+FooRsW5fe8=
 github.com/aws/aws-sdk-go-v2/service/workspaces v1.38.4 h1:SvHYikdxmnyptMebU3zFfXbfU96SHzdUX+KXqa6pjYE=
 github.com/aws/aws-sdk-go-v2/service/workspaces v1.38.4/go.mod h1:1XK49PATLHBd7mpKqO91GqRuV7bEsmyQ8Lslvn3fFj4=
-github.com/aws/smithy-go v1.22.1 h1:/HPHZQ0g7f4eUeK6HKglFz8uwVfZKgoI25rb/J+dnro=
-github.com/aws/smithy-go v1.22.1/go.mod h1:irrKGvNn1InZwb2d7fkIRNucdfwR8R+Ts3wxYa/cJHg=
+github.com/aws/smithy-go v1.22.2 h1:6D9hW43xKFrRx/tXXfAlIZc4JI+yQe6snnWcQyxSyLQ=
+github.com/aws/smithy-go v1.22.2/go.mod h1:irrKGvNn1InZwb2d7fkIRNucdfwR8R+Ts3wxYa/cJHg=
 github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
 github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8=
 github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=


Test patch: