Amazon Redshift will no longer support the creation of new Python UDFs starting Patch 198. Existing Python UDFs will continue to function until June 30, 2026. For more information, see the [ blog post ](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/). # SVCS views for main and concurrency scaling clusters SVCS system views with the prefix SVCS provide details about queries on both the main and concurrency scaling clusters. The views are similar to the tables with the prefix STL except that the STL tables provide information only for queries run on the main cluster. **Topics** + [SVCS\$1ALERT\$1EVENT\$1LOG](r_SVCS_ALERT_EVENT_LOG.md) + [SVCS\$1COMPILE](r_SVCS_COMPILE.md) + [SVCS\$1CONCURRENCY\$1SCALING\$1USAGE](r_SVCS_CONCURRENCY_SCALING_USAGE.md) + [SVCS\$1EXPLAIN](r_SVCS_EXPLAIN.md) + [SVCS\$1PLAN\$1INFO](r_SVCS_PLAN_INFO.md) + [SVCS\$1QUERY\$1SUMMARY](r_SVCS_QUERY_SUMMARY.md) + [SVCS\$1S3LIST](r_SVCS_S3LIST.md) + [SVCS\$1S3LOG](r_SVCS_S3LOG.md) + [SVCS\$1S3PARTITION\$1SUMMARY](r_SVCS_S3PARTITION_SUMMARY.md) + [SVCS\$1S3QUERY\$1SUMMARY](r_SVCS_S3QUERY_SUMMARY.md) + [SVCS\$1STREAM\$1SEGS](r_SVCS_STREAM_SEGS.md) + [SVCS\$1UNLOAD\$1LOG](r_SVCS_UNLOAD_LOG.md) # SVCS\$1ALERT\$1EVENT\$1LOG Records an alert when the query optimizer identifies conditions that might indicate performance issues. This view is derived from the STL\$1ALERT\$1EVENT\$1LOG system table but doesn't show slice-level for queries run on a concurrency scaling cluster. Use the SVCS\$1ALERT\$1EVENT\$1LOG table to identify opportunities to improve query performance. A query consists of multiple segments, and each segment consists of one or more steps. For more information, see [Query processing](c-query-processing.md). **Note** System views with the prefix SVCS provide details about queries on both the main and concurrency scaling clusters. The views are similar to the tables with the prefix STL except that the STL tables provide information only for queries run on the main cluster. SVCS\$1ALERT\$1EVENT\$1LOG is visible to all users. Superusers can see all rows; regular users can see only their own data. For more information, see [Visibility of data in system tables and views](cm_chap_system-tables.md#c_visibility-of-data). ## Table columns [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/redshift/latest/dg/r_SVCS_ALERT_EVENT_LOG.html) ## Usage notes You can use the SVCS\$1ALERT\$1EVENT\$1LOG to identify potential issues in your queries, then follow the practices in [Query performance tuning](c-optimizing-query-performance.md) to optimize your database design and rewrite your queries. SVCS\$1ALERT\$1EVENT\$1LOG records the following alerts: + **Missing statistics** Statistics are missing. Run ANALYZE following data loads or significant updates and use STATUPDATE with COPY operations. For more information, see [Amazon Redshift best practices for designing queries](c_designing-queries-best-practices.md). + **Nested loop ** A nested loop is usually a Cartesian product. Evaluate your query to ensure that all participating tables are joined efficiently. + **Very selective filter** The ratio of rows returned to rows scanned is less than 0.05. Rows scanned is the value of `rows_pre_user_filter `and rows returned is the value of rows in the [STL\$1SCAN](r_STL_SCAN.md) system table. Indicates that the query is scanning an unusually large number of rows to determine the result set. This can be caused by missing or incorrect sort keys. For more information, see [Sort keys](t_Sorting_data.md). + **Excessive ghost rows ** A scan skipped a relatively large number of rows that are marked as deleted but not vacuumed, or rows that have been inserted but not committed. For more information, see [Vacuuming tables](t_Reclaiming_storage_space202.md). + **Large distribution ** More than 1,000,000 rows were redistributed for hash join or aggregation. For more information, see [Data distribution for query optimization](t_Distributing_data.md). + **Large broadcast ** More than 1,000,000 rows were broadcast for hash join. For more information, see [Data distribution for query optimization](t_Distributing_data.md). + **Serial execution ** A DS\$1DIST\$1ALL\$1INNER redistribution style was indicated in the query plan, which forces serial execution because the entire inner table was redistributed to a single node. For more information, see [Data distribution for query optimization](t_Distributing_data.md). ## Sample queries The following query shows alert events for four queries. ``` SELECT query, substring(event,0,25) as event, substring(solution,0,25) as solution, trim(event_time) as event_time from svcs_alert_event_log order by query; query | event | solution | event_time -------+-------------------------------+------------------------------+--------------------- 6567 | Missing query planner statist | Run the ANALYZE command | 2014-01-03 18:20:58 7450 | Scanned a large number of del | Run the VACUUM command to rec| 2014-01-03 21:19:31 8406 | Nested Loop Join in the query | Review the join predicates to| 2014-01-04 00:34:22 29512 | Very selective query filter:r | Review the choice of sort key| 2014-01-06 22:00:00 (4 rows) ``` # SVCS\$1COMPILE Records compile time and location for each query segment of queries, including queries run on a scaling cluster as well as queries run on the main cluster. **Note** System views with the prefix SVCS provide details about queries on both the main and concurrency scaling clusters. The views are similar to the views with the prefix SVL except that the SVL views provide information only for queries run on the main cluster. SVCS\$1COMPILE is visible to all users. Superusers can see all rows; regular users can see only their own data. For more information, see [Visibility of data in system tables and views](cm_chap_system-tables.md#c_visibility-of-data). For information about SCL\$1COMPILE, see [SVL\$1COMPILE](r_SVL_COMPILE.md). ## Table columns [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/redshift/latest/dg/r_SVCS_COMPILE.html) ## Sample queries In this example, queries 35878 and 35879 ran the same SQL statement. The compile column for query 35878 shows `1` for four query segments, which indicates that the segments were compiled. Query 35879 shows `0` in the compile column for every segment, indicating that the segments did not need to be compiled again. ``` select userid, xid, pid, query, segment, locus, datediff(ms, starttime, endtime) as duration, compile from svcs_compile where query = 35878 or query = 35879 order by query, segment; userid | xid | pid | query | segment | locus | duration | compile --------+--------+-------+-------+---------+-------+----------+--------- 100 | 112780 | 23028 | 35878 | 0 | 1 | 0 | 0 100 | 112780 | 23028 | 35878 | 1 | 1 | 0 | 0 100 | 112780 | 23028 | 35878 | 2 | 1 | 0 | 0 100 | 112780 | 23028 | 35878 | 3 | 1 | 0 | 0 100 | 112780 | 23028 | 35878 | 4 | 1 | 0 | 0 100 | 112780 | 23028 | 35878 | 5 | 1 | 0 | 0 100 | 112780 | 23028 | 35878 | 6 | 1 | 1380 | 1 100 | 112780 | 23028 | 35878 | 7 | 1 | 1085 | 1 100 | 112780 | 23028 | 35878 | 8 | 1 | 1197 | 1 100 | 112780 | 23028 | 35878 | 9 | 2 | 905 | 1 100 | 112782 | 23028 | 35879 | 0 | 1 | 0 | 0 100 | 112782 | 23028 | 35879 | 1 | 1 | 0 | 0 100 | 112782 | 23028 | 35879 | 2 | 1 | 0 | 0 100 | 112782 | 23028 | 35879 | 3 | 1 | 0 | 0 100 | 112782 | 23028 | 35879 | 4 | 1 | 0 | 0 100 | 112782 | 23028 | 35879 | 5 | 1 | 0 | 0 100 | 112782 | 23028 | 35879 | 6 | 1 | 0 | 0 100 | 112782 | 23028 | 35879 | 7 | 1 | 0 | 0 100 | 112782 | 23028 | 35879 | 8 | 1 | 0 | 0 100 | 112782 | 23028 | 35879 | 9 | 2 | 0 | 0 (20 rows) ``` # SVCS\$1CONCURRENCY\$1SCALING\$1USAGE Records the usage periods for concurrency scaling. Each usage period is a consecutive duration where an individual concurrency scaling cluster is actively processing queries. SVCS\$1CONCURRENCY\$1SCALING\$1USAGE This table is visible to superusers. The database's superuser can choose to open it up to all users. ## Table columns [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/redshift/latest/dg/r_SVCS_CONCURRENCY_SCALING_USAGE.html) ## Sample queries To view the usage duration in seconds for a specific period, enter the following query: ``` select * from svcs_concurrency_scaling_usage order by start_time; start_time | end_time | queries | usage_in_seconds ----------------------------+----------------------------+---------+------------------ 2019-02-14 18:43:53.01063 | 2019-02-14 19:16:49.781649 | 48 | 1977 ``` # SVCS\$1EXPLAIN Displays the EXPLAIN plan for a query that has been submitted for execution. **Note** System views with the prefix SVCS provide details about queries on both the main and concurrency scaling clusters. The views are similar to the tables with the prefix STL except that the STL tables provide information only for queries run on the main cluster. SVCS\$1EXPLAIN is visible to all users. Superusers can see all rows; regular users can see only their own data. For more information, see [Visibility of data in system tables and views](cm_chap_system-tables.md#c_visibility-of-data). ## Table columns [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/redshift/latest/dg/r_SVCS_EXPLAIN.html) ## Sample queries Consider the following EXPLAIN output for an aggregate join query: ``` explain select avg(datediff(day, listtime, saletime)) as avgwait from sales, listing where sales.listid = listing.listid; QUERY PLAN ------------------------------------------------------------------------------ XN Aggregate (cost=6350.30..6350.31 rows=1 width=16) -> XN Hash Join DS_DIST_NONE (cost=47.08..6340.89 rows=3766 width=16) Hash Cond: ("outer".listid = "inner".listid) -> XN Seq Scan on listing (cost=0.00..1924.97 rows=192497 width=12) -> XN Hash (cost=37.66..37.66 rows=3766 width=12) -> XN Seq Scan on sales (cost=0.00..37.66 rows=3766 width=12) (6 rows) ``` If you run this query and its query ID is 10, you can use the SVCS\$1EXPLAIN table to see the same kind of information that the EXPLAIN command returns: ``` select query,nodeid,parentid,substring(plannode from 1 for 30), substring(info from 1 for 20) from svcs_explain where query=10 order by 1,2; query| nodeid |parentid| substring | substring -----+--------+--------+--------------------------------+------------------- 10 | 1 | 0 |XN Aggregate (cost=6717.61..6 | 10 | 2 | 1 | -> XN Merge Join DS_DIST_NO| Merge Cond:("outer" 10 | 3 | 2 | -> XN Seq Scan on lis | 10 | 4 | 2 | -> XN Seq Scan on sal | (4 rows) ``` Consider the following query: ``` select event.eventid, sum(pricepaid) from event, sales where event.eventid=sales.eventid group by event.eventid order by 2 desc; eventid | sum --------+---------- 289 | 51846.00 7895 | 51049.00 1602 | 50301.00 851 | 49956.00 7315 | 49823.00 ... ``` If this query's ID is 15, the following system table query returns the plan nodes that were performed. In this case, the order of the nodes is reversed to show the actual order of execution: ``` select query,nodeid,parentid,substring(plannode from 1 for 56) from svcs_explain where query=15 order by 1, 2 desc; query|nodeid|parentid| substring -----+------+--------+-------------------------------------------------------- 15 | 8 | 7 | -> XN Seq Scan on eve 15 | 7 | 5 | -> XN Hash(cost=87.98..87.9 15 | 6 | 5 | -> XN Seq Scan on sales(cos 15 | 5 | 4 | -> XN Hash Join DS_DIST_OUTER(cos 15 | 4 | 3 | -> XN HashAggregate(cost=862286577.07.. 15 | 3 | 2 | -> XN Sort(cost=1000862287175.47..10008622871 15 | 2 | 1 | -> XN Network(cost=1000862287175.47..1000862287197. 15 | 1 | 0 |XN Merge(cost=1000862287175.47..1000862287197.46 rows=87 (8 rows) ``` The following query retrieves the query IDs for any query plans that contain a window function: ``` select query, trim(plannode) from svcs_explain where plannode like '%Window%'; query| btrim -----+------------------------------------------------------------------------ 26 | -> XN Window(cost=1000985348268.57..1000985351256.98 rows=170 width=33) 27 | -> XN Window(cost=1000985348268.57..1000985351256.98 rows=170 width=33) (2 rows) ``` # SVCS\$1PLAN\$1INFO Use the SVCS\$1PLAN\$1INFO table to look at the EXPLAIN output for a query in terms of a set of rows. This is an alternative way to look at query plans. **Note** System views with the prefix SVCS provide details about queries on both the main and concurrency scaling clusters. The views are similar to the tables with the prefix STL except that the STL tables provide information only for queries run on the main cluster. SVCS\$1PLAN\$1INFO is visible to all users. Superusers can see all rows; regular users can see only their own data. For more information, see [Visibility of data in system tables and views](cm_chap_system-tables.md#c_visibility-of-data). ## Table columns [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/redshift/latest/dg/r_SVCS_PLAN_INFO.html) ## Sample queries The following examples compare the query plans for a simple SELECT query returned by using the EXPLAIN command and by querying the SVCS\$1PLAN\$1INFO table. ``` explain select * from category; QUERY PLAN ------------------------------------------------------------- XN Seq Scan on category (cost=0.00..0.11 rows=11 width=49) (1 row) select * from category; catid | catgroup | catname | catdesc -------+----------+-----------+-------------------------------------------- 1 | Sports | MLB | Major League Baseball 3 | Sports | NFL | National Football League 5 | Sports | MLS | Major League Soccer ... select * from svcs_plan_info where query=256; query | nodeid | segment | step | locus | plannode | startupcost | totalcost | rows | bytes -------+--------+---------+------+-------+----------+-------------+-----------+------+------- 256 | 1 | 0 | 1 | 0 | 104 | 0 | 0.11 | 11 | 539 256 | 1 | 0 | 0 | 0 | 104 | 0 | 0.11 | 11 | 539 (2 rows) ``` In this example, PLANNODE 104 refers to the sequential scan of the CATEGORY table. ``` select distinct eventname from event order by 1; eventname ------------------------------------------------------------------------ .38 Special 3 Doors Down 70s Soul Jam A Bronx Tale ... explain select distinct eventname from event order by 1; QUERY PLAN ------------------------------------------------------------------------------------- XN Merge (cost=1000000000136.38..1000000000137.82 rows=576 width=17) Merge Key: eventname -> XN Network (cost=1000000000136.38..1000000000137.82 rows=576 width=17) Send to leader -> XN Sort (cost=1000000000136.38..1000000000137.82 rows=576 width=17) Sort Key: eventname -> XN Unique (cost=0.00..109.98 rows=576 width=17) -> XN Seq Scan on event (cost=0.00..87.98 rows=8798 width=17) (8 rows) select * from svcs_plan_info where query=240 order by nodeid desc; query | nodeid | segment | step | locus | plannode | startupcost | totalcost | rows | bytes -------+--------+---------+------+-------+----------+------------------+------------------+------+-------- 240 | 5 | 0 | 0 | 0 | 104 | 0 | 87.98 | 8798 | 149566 240 | 5 | 0 | 1 | 0 | 104 | 0 | 87.98 | 8798 | 149566 240 | 4 | 0 | 2 | 0 | 117 | 0 | 109.975 | 576 | 9792 240 | 4 | 0 | 3 | 0 | 117 | 0 | 109.975 | 576 | 9792 240 | 4 | 1 | 0 | 0 | 117 | 0 | 109.975 | 576 | 9792 240 | 4 | 1 | 1 | 0 | 117 | 0 | 109.975 | 576 | 9792 240 | 3 | 1 | 2 | 0 | 114 | 1000000000136.38 | 1000000000137.82 | 576 | 9792 240 | 3 | 2 | 0 | 0 | 114 | 1000000000136.38 | 1000000000137.82 | 576 | 9792 240 | 2 | 2 | 1 | 0 | 123 | 1000000000136.38 | 1000000000137.82 | 576 | 9792 240 | 1 | 3 | 0 | 0 | 122 | 1000000000136.38 | 1000000000137.82 | 576 | 9792 (10 rows) ``` # SVCS\$1QUERY\$1SUMMARY Use the SVCS\$1QUERY\$1SUMMARY view to find general information about the execution of a query. Note that the information in SVCS\$1QUERY\$1SUMMARY is aggregated from all nodes. **Note** The SVCS\$1QUERY\$1SUMMARY view only contains information about queries completed by Amazon Redshift, not other utility and DDL commands. For a complete listing and information on all statements completed by Amazon Redshift, including DDL and utility commands, you can query the SVL\$1STATEMENTTEXT view. System views with the prefix SVCS provide details about queries on both the main and concurrency scaling clusters. The views are similar to the views with the prefix SVL except that the SVL views provide information only for queries run on the main cluster. SVCS\$1QUERY\$1SUMMARY is visible to all users. Superusers can see all rows; regular users can see only their own data. For more information, see [Visibility of data in system tables and views](cm_chap_system-tables.md#c_visibility-of-data). Some or all of the data in this table can also be found in the SYS monitoring view [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md). The data in the SYS monitoring view is formatted to be easier to use and understand. We recommend that you use the SYS monitoring view for your queries. For information about SVL\$1QUERY\$1SUMMARY, see [SVL\$1QUERY\$1SUMMARY](r_SVL_QUERY_SUMMARY.md). ## Table columns [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/redshift/latest/dg/r_SVCS_QUERY_SUMMARY.html) ## Sample queries **Viewing processing information for a query step** The following query shows basic processing information for each step of query 87: ``` select query, stm, seg, step, rows, bytes from svcs_query_summary where query = 87 order by query, seg, step; ``` This query retrieves the processing information about query 87, as shown in the following sample output: ``` query | stm | seg | step | rows | bytes -------+-----+-----+------+--------+--------- 87 | 0 | 0 | 0 | 90 | 1890 87 | 0 | 0 | 2 | 90 | 360 87 | 0 | 1 | 0 | 90 | 360 87 | 0 | 1 | 2 | 90 | 1440 87 | 1 | 2 | 0 | 210494 | 4209880 87 | 1 | 2 | 3 | 89500 | 0 87 | 1 | 2 | 6 | 4 | 96 87 | 2 | 3 | 0 | 4 | 96 87 | 2 | 3 | 1 | 4 | 96 87 | 2 | 4 | 0 | 4 | 96 87 | 2 | 4 | 1 | 1 | 24 87 | 3 | 5 | 0 | 1 | 24 87 | 3 | 5 | 4 | 0 | 0 (13 rows) ``` **Determining whether query steps spilled to disk** The following query shows whether or not any of the steps for the query with query ID 1025 (see the [SVL\$1QLOG](r_SVL_QLOG.md) view to learn how to obtain the query ID for a query) spilled to disk or if the query ran entirely in-memory: ``` select query, step, rows, workmem, label, is_diskbased from svcs_query_summary where query = 1025 order by workmem desc; ``` This query returns the following sample output: ``` query| step| rows | workmem | label | is_diskbased -----+-----+--------+-----------+---------------+-------------- 1025 | 0 |16000000| 141557760 |scan tbl=9 | f 1025 | 2 |16000000| 135266304 |hash tbl=142 | t 1025 | 0 |16000000| 128974848 |scan tbl=116536| f 1025 | 2 |16000000| 122683392 |dist | f (4 rows) ``` By scanning the values for IS\$1DISKBASED, you can see which query steps went to disk. For query 1025, the hash step ran on disk. Steps might run on disk include hash, aggr, and sort steps. To view only disk-based query steps, add **and is\$1diskbased = 't'** clause to the SQL statement in the above example. # SVCS\$1S3LIST Use the SVCS\$1S3LIST view to get details about Amazon Redshift Spectrum queries at the segment level. One segment can perform one external table scan. This view is derived from the SVL\$1S3LIST system view but doesn't show slice-level for queries run on a concurrency scaling cluster. **Note** System views with the prefix SVCS provide details about queries on both the main and concurrency scaling clusters. The views are similar to the views with the prefix SVL except that the SVL views provide information only for queries run on the main cluster. SVCS\$1S3LIST is visible to all users. Superusers can see all rows; regular users can see only their own data. For more information, see [Visibility of data in system tables and views](cm_chap_system-tables.md#c_visibility-of-data). For information about SVL\$1S3LIST, see [SVL\$1S3LIST](r_SVL_S3LIST.md). ## Table columns [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/redshift/latest/dg/r_SVCS_S3LIST.html) ## Sample query The following example queries SVCS\$1S3LIST for the last query performed. ``` select * from svcs_s3list where query = pg_last_query_id() order by query,segment; ``` # SVCS\$1S3LOG Use the SVCS\$1S3LOG view to get troubleshooting details about Redshift Spectrum queries at the segment level. One segment can perform one external table scan. This view is derived from the SVL\$1S3LOG system view but doesn't show slice-level for queries run on a concurrency scaling cluster. **Note** System views with the prefix SVCS provide details about queries on both the main and concurrency scaling clusters. The views are similar to the views with the prefix SVL except that the SVL views provide information only for queries run on the main cluster. SVCS\$1S3LOG is visible to all users. Superusers can see all rows; regular users can see only their own data. For more information, see [Visibility of data in system tables and views](cm_chap_system-tables.md#c_visibility-of-data). For information about SVL\$1S3LOG, see [SVL\$1S3LOG](r_SVL_S3LOG.md). ## Table columns [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/redshift/latest/dg/r_SVCS_S3LOG.html) ## Sample query The following example queries SVCS\$1S3LOG for the last query that ran. ``` select * from svcs_s3log where query = pg_last_query_id() order by query,segment; ``` # SVCS\$1S3PARTITION\$1SUMMARY Use the SVCS\$1S3PARTITION\$1SUMMARY view to get a summary of Redshift Spectrum queries partition processing at the segment level. One segment can perform one external table scan. **Note** System views with the prefix SVCS provide details about queries on both the main and concurrency scaling clusters. The views are similar to the views with the prefix SVL except that the SVL views provide information only for queries run on the main cluster. SVCS\$1S3PARTITION\$1SUMMARY is visible to all users. Superusers can see all rows; regular users can see only their own data. For more information, see [Visibility of data in system tables and views](cm_chap_system-tables.md#c_visibility-of-data). For information about SVL\$1S3PARTITION, see [SVL\$1S3PARTITION](r_SVL_S3PARTITION.md). ## Table columns [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/redshift/latest/dg/r_SVCS_S3PARTITION_SUMMARY.html) ## Sample query The following example gets the partition scan details for the last query performed. ``` select query, segment, assignment, min_starttime, max_endtime, min_duration, avg_duration from svcs_s3partition_summary where query = pg_last_query_id() order by query,segment; ``` # SVCS\$1S3QUERY\$1SUMMARY Use the SVCS\$1S3QUERY\$1SUMMARY view to get a summary of all Redshift Spectrum queries (S3 queries) that have been run on the system. One segment can perform one external table scan. **Note** System views with the prefix SVCS provide details about queries on both the main and concurrency scaling clusters. The views are similar to the views with the prefix SVL except that the SVL views provide information only for queries run on the main cluster. SVCS\$1S3QUERY\$1SUMMARY is visible to all users. Superusers can see all rows; regular users can see only their own data. For more information, see [Visibility of data in system tables and views](cm_chap_system-tables.md#c_visibility-of-data). For information about SVL\$1S3QUERY, see [SVL\$1S3QUERY](r_SVL_S3QUERY.md). ## Table columns [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/redshift/latest/dg/r_SVCS_S3QUERY_SUMMARY.html) ## Sample query The following example gets the scan step details for the last query run. ``` select query, segment, elapsed, s3_scanned_rows, s3_scanned_bytes, s3query_returned_rows, s3query_returned_bytes, files from svcs_s3query_summary where query = pg_last_query_id() order by query,segment; ``` ``` query | segment | elapsed | s3_scanned_rows | s3_scanned_bytes | s3query_returned_rows | s3query_returned_bytes | files ------+---------+---------+-----------------+------------------+-----------------------+------------------------+------ 4587 | 2 | 67811 | 0 | 0 | 0 | 0 | 0 4587 | 2 | 591568 | 172462 | 11260097 | 8513 | 170260 | 1 4587 | 2 | 216849 | 0 | 0 | 0 | 0 | 0 4587 | 2 | 216671 | 0 | 0 | 0 | 0 | 0 ``` # SVCS\$1STREAM\$1SEGS Lists the relationship between streams and concurrent segments. **Note** System views with the prefix SVCS provide details about queries on both the main and concurrency scaling clusters. The views are similar to the tables with the prefix STL except that the STL tables provide information only for queries run on the main cluster. SVCS\$1STREAM\$1SEGS is visible to all users. Superusers can see all rows; regular users can see only their own data. For more information, see [Visibility of data in system tables and views](cm_chap_system-tables.md#c_visibility-of-data). ## Table columns [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/redshift/latest/dg/r_SVCS_STREAM_SEGS.html) ## Sample queries To view the relationship between streams and concurrent segments for the most recent query, type the following query: ``` select * from svcs_stream_segs where query = pg_last_query_id(); query | stream | segment -------+--------+--------- 10 | 1 | 2 10 | 0 | 0 10 | 2 | 4 10 | 1 | 3 10 | 0 | 1 (5 rows) ``` # SVCS\$1UNLOAD\$1LOG Use the SVCS\$1UNLOAD\$1LOG to get details of UNLOAD operations. SVCS\$1UNLOAD\$1LOG records one row for each file created by an UNLOAD statement. For example, if an UNLOAD creates 12 files, SVCS\$1UNLOAD\$1LOG contains 12 corresponding rows. This view is derived from the STL\$1UNLOAD\$1LOG system table but doesn't show slice-level for queries run on a concurrency scaling cluster. **Note** System views with the prefix SVCS provide details about queries on both the main and concurrency scaling clusters. The views are similar to the tables with the prefix STL except that the STL tables provide information only for queries run on the main cluster. SVCS\$1UNLOAD\$1LOG is visible to all users. Superusers can see all rows; regular users can see only their own data. For more information, see [Visibility of data in system tables and views](cm_chap_system-tables.md#c_visibility-of-data). ## Table columns [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/redshift/latest/dg/r_SVCS_UNLOAD_LOG.html) ## Sample query To get a list of the files that were written to Amazon S3 by an UNLOAD command, you can call an Amazon S3 list operation after the UNLOAD completes; however, depending on how quickly you issue the call, the list might be incomplete because an Amazon S3 list operation is eventually consistent. To get a complete, authoritative list immediately, query SVCS\$1UNLOAD\$1LOG. The following query returns the path name for files that were created by an UNLOAD for the last query completed: ``` select query, substring(path,0,40) as path from svcs_unload_log where query = pg_last_query_id() order by path; ``` This command returns the following sample output: ``` query | path ------+--------------------------------------------- 2320 | s3://amzn-s3-demo-bucket/venue0000_part_00 2320 | s3://amzn-s3-demo-bucket/venue0001_part_00 2320 | s3://amzn-s3-demo-bucket/venue0002_part_00 2320 | s3://amzn-s3-demo-bucket/venue0003_part_00 (4 rows) ```