Method getPolicyDefsForTables

database/postgres/database.go:1606–1645

(tableNames []string)

}

func (d *PostgresDatabase) getPolicyDefsForTables(tableNames []string) (map[string][]string, error) {
	const query = `
		SELECT schemaname || '.' || tablename AS qualified_table_name, schemaname, tablename, policyname, permissive, roles, cmd, qual, with_check
		FROM pg_policies
		WHERE schemaname || '.' || tablename = ANY($1::text[])
	`
	rows, err := d.db.Query(query, pq.Array(tableNames))
	if err != nil {
		return nil, err
	}
	defer rows.Close()

	result := make(map[string][]string, len(tableNames))
	for rows.Next() {
		var (
			qualifiedTableName, schemaName, tableName, policyName, permissive, roles, cmd string
			using, withCheck                                                              sql.NullString
		)
		err = rows.Scan(&qualifiedTableName, &schemaName, &tableName, &policyName, &permissive, &roles, &cmd, &using, &withCheck)
		if err != nil {
			return nil, err
		}
		roles = policyRolesPrefixRegex.ReplaceAllString(roles, "")
		roles = policyRolesSuffixRegex.ReplaceAllString(roles, "")
		// Qualify the table name with its schema; otherwise policies on tables
		// outside the default schema resolve to the wrong table when re-parsed
		def := fmt.Sprintf(
			"CREATE POLICY %s ON %s.%s AS %s FOR %s TO %s",
			policyName, d.quoteIdentifierIfNeeded(schemaName), d.quoteIdentifierIfNeeded(tableName), permissive, cmd, roles,
		)
		if using.Valid {
			def += fmt.Sprintf(" USING (%s)", using.String)
		}
		if withCheck.Valid {
			def += fmt.Sprintf(" WITH CHECK %s", withCheck.String)
		}
		result[qualifiedTableName] = append(result[qualifiedTableName], def+";")
	}
	return result, nil
}

func (d *PostgresDatabase) getCheckConstraintsForTables(tableNames []string) (map[string][]CheckConstraint, error) {
	const query = `SELECT nsp.nspname || '.' || cls.relname AS qualified_table_name, con.conname, pg_get_constraintdef(con.oid, true)