== Parsed Logical Plan ==
'GlobalLimit 5
+- 'LocalLimit 5
   +- 'Sort ['C_23 DESC NULLS LAST], true
      +- 'Project ['C_0 AS C_12#5654, 'C_1 AS C_17#5655, 'C_2 AS C_14#5656, 'C_4331 AS C_25#5657, 'C_4332 AS C_18#5658, 'C_4333 AS C_21#5659, 'C_4 AS C_22#5660, 'C_6 AS C_19#5661, 'C_8 AS C_13#5662, 'C_9 AS C_20#5663, 'C_10 AS C_24#5664, 'C_43 AS C_16#5665, 'C_11 AS C_15#5666, 'C_7 AS C_23#5667]
         +- 'SubqueryAlias C_4954424c
            +- 'Project ['C_64656661756c745f616972706f727473.id AS C_0#5638, 'C_64656661756c745f616972706f727473.type AS C_1#5639, 'C_64656661756c745f616972706f727473.name AS C_2#5640, 'C_64656661756c745f616972706f727473.lat AS C_5#5641, 'C_64656661756c745f616972706f727473.lon AS C_3#5642, 'C_64656661756c745f616972706f727473.elev AS C_7#5643, 'C_64656661756c745f616972706f727473.continent AS C_4#5644, 'C_64656661756c745f616972706f727473.country AS C_6#5645, 'C_64656661756c745f616972706f727473.region AS C_8#5646, 'C_64656661756c745f616972706f727473.city AS C_9#5647, 'C_64656661756c745f616972706f727473.iata AS C_10#5648, 'C_64656661756c745f616972706f727473.code AS C_43#5649, 'C_64656661756c745f616972706f727473.gps AS C_11#5650, ('round(('C_64656661756c745f616972706f727473.lat * 'power(10.0, 3)), 0) / 'power(10.0, 3)) AS C_4331#5651, ('round(('C_64656661756c745f616972706f727473.lon * 'power(10.0, 3)), 0) / 'power(10.0, 3)) AS C_4332#5652, ('round(('C_64656661756c745f616972706f727473.elev * 'power(10.0, 3)), 0) / 'power(10.0, 3)) AS C_4333#5653]
               +- 'Filter ((('C_64656661756c745f616972706f727473.lon <= -104.05) AND ('C_64656661756c745f616972706f727473.lon >= -111.05)) AND (('C_64656661756c745f616972706f727473.lat >= 41.0) AND ('C_64656661756c745f616972706f727473.lat <= 45.0)))
                  +- 'SubqueryAlias C_64656661756c745f616972706f727473
                     +- 'UnresolvedRelation [default, airports], [], false

== Analyzed Logical Plan ==
C_12: string, C_17: string, C_14: string, C_25: double, C_18: double, C_21: double, C_22: string, C_19: string, C_13: string, C_20: string, C_24: string, C_16: string, C_15: string, C_23: double
GlobalLimit 5
+- LocalLimit 5
   +- Sort [C_23#5667 DESC NULLS LAST], true
      +- Project [C_0#5638 AS C_12#5654, C_1#5639 AS C_17#5655, C_2#5640 AS C_14#5656, C_4331#5651 AS C_25#5657, C_4332#5652 AS C_18#5658, C_4333#5653 AS C_21#5659, C_4#5644 AS C_22#5660, C_6#5645 AS C_19#5661, C_8#5646 AS C_13#5662, C_9#5647 AS C_20#5663, C_10#5648 AS C_24#5664, C_43#5649 AS C_16#5665, C_11#5650 AS C_15#5666, C_7#5643 AS C_23#5667]
         +- SubqueryAlias C_4954424c
            +- Project [id#5668 AS C_0#5638, type#5669 AS C_1#5639, name#5670 AS C_2#5640, lat#5671 AS C_5#5641, lon#5672 AS C_3#5642, elev#5673 AS C_7#5643, continent#5674 AS C_4#5644, country#5675 AS C_6#5645, region#5676 AS C_8#5646, city#5677 AS C_9#5647, iata#5678 AS C_10#5648, code#5679 AS C_43#5649, gps#5680 AS C_11#5650, (round((lat#5671 * POWER(10.0, cast(3 as double))), 0) / POWER(10.0, cast(3 as double))) AS C_4331#5651, (round((lon#5672 * POWER(10.0, cast(3 as double))), 0) / POWER(10.0, cast(3 as double))) AS C_4332#5652, (round((elev#5673 * POWER(10.0, cast(3 as double))), 0) / POWER(10.0, cast(3 as double))) AS C_4333#5653]
               +- Filter (((lon#5672 <= -104.05) AND (lon#5672 >= -111.05)) AND ((lat#5671 >= 41.0) AND (lat#5671 <= 45.0)))
                  +- SubqueryAlias C_64656661756c745f616972706f727473
                     +- SubqueryAlias spark_catalog.default.airports
                        +- Relation spark_catalog.default.airports[id#5668,type#5669,name#5670,lat#5671,lon#5672,elev#5673,continent#5674,country#5675,region#5676,city#5677,iata#5678,code#5679,gps#5680] parquet

== Optimized Logical Plan ==
GlobalLimit 5
+- LocalLimit 5
   +- Sort [C_23#5667 DESC NULLS LAST], true
      +- Project [id#5668 AS C_12#5654, type#5669 AS C_17#5655, name#5670 AS C_14#5656, (round((lat#5671 * 1000.0), 0) / 1000.0) AS C_25#5657, (round((lon#5672 * 1000.0), 0) / 1000.0) AS C_18#5658, (round((elev#5673 * 1000.0), 0) / 1000.0) AS C_21#5659, continent#5674 AS C_22#5660, country#5675 AS C_19#5661, region#5676 AS C_13#5662, city#5677 AS C_20#5663, iata#5678 AS C_24#5664, code#5679 AS C_16#5665, gps#5680 AS C_15#5666, elev#5673 AS C_23#5667]
         +- Filter ((isnotnull(lon#5672) AND isnotnull(lat#5671)) AND (((lon#5672 <= -104.05) AND (lon#5672 >= -111.05)) AND ((lat#5671 >= 41.0) AND (lat#5671 <= 45.0))))
            +- Relation spark_catalog.default.airports[id#5668,type#5669,name#5670,lat#5671,lon#5672,elev#5673,continent#5674,country#5675,region#5676,city#5677,iata#5678,code#5679,gps#5680] parquet

== Physical Plan ==
TakeOrderedAndProject(limit=5, orderBy=[C_23#5667 DESC NULLS LAST], output=[C_12#5654,C_17#5655,C_14#5656,C_25#5657,C_18#5658,C_21#5659,C_22#5660,C_19#5661,C_13#5662,C_20#5663,C_24#5664,C_16#5665,C_15#5666,C_23#5667])
+- *(1) Project [id#5668 AS C_12#5654, type#5669 AS C_17#5655, name#5670 AS C_14#5656, (round((lat#5671 * 1000.0), 0) / 1000.0) AS C_25#5657, (round((lon#5672 * 1000.0), 0) / 1000.0) AS C_18#5658, (round((elev#5673 * 1000.0), 0) / 1000.0) AS C_21#5659, continent#5674 AS C_22#5660, country#5675 AS C_19#5661, region#5676 AS C_13#5662, city#5677 AS C_20#5663, iata#5678 AS C_24#5664, code#5679 AS C_16#5665, gps#5680 AS C_15#5666, elev#5673 AS C_23#5667]
   +- *(1) Filter (((((isnotnull(lon#5672) AND isnotnull(lat#5671)) AND (lon#5672 <= -104.05)) AND (lon#5672 >= -111.05)) AND (lat#5671 >= 41.0)) AND (lat#5671 <= 45.0))
      +- *(1) ColumnarToRow
         +- FileScan parquet spark_catalog.default.airports[id#5668,type#5669,name#5670,lat#5671,lon#5672,elev#5673,continent#5674,country#5675,region#5676,city#5677,iata#5678,code#5679,gps#5680] Batched: true, DataFilters: [isnotnull(lon#5672), isnotnull(lat#5671), (lon#5672 <= -104.05), (lon#5672 >= -111.05), (lat#567..., Format: Parquet, Location: InMemoryFileIndex(1 paths)[file:/home/acdcadmin/spark-warehouse/airports], PartitionFilters: [], PushedFilters: [IsNotNull(lon), IsNotNull(lat), LessThanOrEqual(lon,-104.05), GreaterThanOrEqual(lon,-111.05), G..., ReadSchema: struct<id:string,type:string,name:string,lat:double,lon:double,elev:double,continent:string,count...

== Parsed Logical Plan ==
'DescribeRelation false, [col_name#5615, data_type#5616, comment#5617]
+- 'UnresolvedTableOrView [default, airports], DESCRIBE TABLE, true

== Analyzed Logical Plan ==
col_name: string, data_type: string, comment: string
DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#5615, data_type#5616, comment#5617]

== Optimized Logical Plan ==
CommandResult [col_name#5615, data_type#5616, comment#5617], Execute DescribeTableCommand, [[id,string,null], [type,string,null], [name,string,null], [lat,double,null], [lon,double,null], [elev,double,null], [continent,string,null], [country,string,null], [region,string,null], [city,string,null], [iata,string,null], [code,string,null], [gps,string,null]]
   +- DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#5615, data_type#5616, comment#5617]

== Physical Plan ==
CommandResult [col_name#5615, data_type#5616, comment#5617]
   +- Execute DescribeTableCommand
         +- DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#5615, data_type#5616, comment#5617]

== Parsed Logical Plan ==
'DescribeRelation false, [col_name#5592, data_type#5593, comment#5594]
+- 'UnresolvedTableOrView [default, airports], DESCRIBE TABLE, true

== Analyzed Logical Plan ==
col_name: string, data_type: string, comment: string
DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#5592, data_type#5593, comment#5594]

== Optimized Logical Plan ==
CommandResult [col_name#5592, data_type#5593, comment#5594], Execute DescribeTableCommand, [[id,string,null], [type,string,null], [name,string,null], [lat,double,null], [lon,double,null], [elev,double,null], [continent,string,null], [country,string,null], [region,string,null], [city,string,null], [iata,string,null], [code,string,null], [gps,string,null]]
   +- DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#5592, data_type#5593, comment#5594]

== Physical Plan ==
CommandResult [col_name#5592, data_type#5593, comment#5594]
   +- Execute DescribeTableCommand
         +- DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#5592, data_type#5593, comment#5594]

== Parsed Logical Plan ==
SetCommand (-v,None)

== Analyzed Logical Plan ==
key: string, value: string, meaning: string, Since version: string
SetCommand (-v,None)

== Optimized Logical Plan ==
CommandResult [key#5567, value#5568, meaning#5569, Since version#5570], Execute SetCommand, [[spark.sql.adaptive.advisoryPartitionSizeInBytes,<value of spark.sql.adaptive.shuffle.targetPostShuffleInputSize>,The advisory size in bytes of the shuffle partition during adaptive optimization (when spark.sql.adaptive.enabled is true). It takes effect when Spark coalesces small shuffle partitions or splits skewed shuffle partition.,3.0.0], [spark.sql.adaptive.autoBroadcastJoinThreshold,<undefined>,Configures the maximum size in bytes for a table that will be broadcast to all worker nodes when performing a join. By setting this value to -1 broadcasting can be disabled. The default value is same with spark.sql.autoBroadcastJoinThreshold. Note that, this config is used only in adaptive framework.,3.2.0], [spark.sql.adaptive.coalescePartitions.enabled,true,When true and 'spark.sql.adaptive.enabled' is true, Spark will coalesce contiguous shuffle partitions according to the target size (specified by 'spark.sql.adaptive.advisoryPartitionSizeInBytes'), to avoid too many small tasks.,3.0.0], [spark.sql.adaptive.coalescePartitions.initialPartitionNum,<undefined>,The initial number of shuffle partitions before coalescing. If not set, it equals to spark.sql.shuffle.partitions. This configuration only has an effect when 'spark.sql.adaptive.enabled' and 'spark.sql.adaptive.coalescePartitions.enabled' are both true.,3.0.0], [spark.sql.adaptive.coalescePartitions.minPartitionSize,1MB,The minimum size of shuffle partitions after coalescing. This is useful when the adaptively calculated target size is too small during partition coalescing.,3.2.0], [spark.sql.adaptive.coalescePartitions.parallelismFirst,true,When true, Spark does not respect the target size specified by 'spark.sql.adaptive.advisoryPartitionSizeInBytes' (default 64MB) when coalescing contiguous shuffle partitions, but adaptively calculate the target size according to the default parallelism of the Spark cluster. The calculated size is usually smaller than the configured target size. This is to maximize the parallelism and avoid performance regression when enabling adaptive query execution. It's recommended to set this config to false and respect the configured target size.,3.2.0], [spark.sql.adaptive.customCostEvaluatorClass,<undefined>,The custom cost evaluator class to be used for adaptive execution. If not being set, Spark will use its own SimpleCostEvaluator by default.,3.2.0], [spark.sql.adaptive.enabled,true,When true, enable adaptive query execution, which re-optimizes the query plan in the middle of query execution, based on accurate runtime statistics.,1.6.0], [spark.sql.adaptive.forceOptimizeSkewedJoin,false,When true, force enable OptimizeSkewedJoin even if it introduces extra shuffle.,3.3.0], [spark.sql.adaptive.localShuffleReader.enabled,true,When true and 'spark.sql.adaptive.enabled' is true, Spark tries to use local shuffle reader to read the shuffle data when the shuffle partitioning is not needed, for example, after converting sort-merge join to broadcast-hash join.,3.0.0], [spark.sql.adaptive.maxShuffledHashJoinLocalMapThreshold,0b,Configures the maximum size in bytes per partition that can be allowed to build local hash map. If this value is not smaller than spark.sql.adaptive.advisoryPartitionSizeInBytes and all the partition size are not larger than this config, join selection prefer to use shuffled hash join instead of sort merge join regardless of the value of spark.sql.join.preferSortMergeJoin.,3.2.0], [spark.sql.adaptive.optimizeSkewsInRebalancePartitions.enabled,true,When true and 'spark.sql.adaptive.enabled' is true, Spark will optimize the skewed shuffle partitions in RebalancePartitions and split them to smaller ones according to the target size (specified by 'spark.sql.adaptive.advisoryPartitionSizeInBytes'), to avoid data skew.,3.2.0], [spark.sql.adaptive.optimizer.excludedRules,<undefined>,Configures a list of rules to be disabled in the adaptive optimizer, in which the rules are specified by their rule names and separated by comma. The optimizer will log the rules that have indeed been excluded.,3.1.0], [spark.sql.adaptive.rebalancePartitionsSmallPartitionFactor,0.2,A partition will be merged during splitting if its size is small than this factor multiply spark.sql.adaptive.advisoryPartitionSizeInBytes.,3.3.0], [spark.sql.adaptive.skewJoin.enabled,true,When true and 'spark.sql.adaptive.enabled' is true, Spark dynamically handles skew in shuffled join (sort-merge and shuffled hash) by splitting (and replicating if needed) skewed partitions.,3.0.0], [spark.sql.adaptive.skewJoin.skewedPartitionFactor,5.0,A partition is considered as skewed if its size is larger than this factor multiplying the median partition size and also larger than 'spark.sql.adaptive.skewJoin.skewedPartitionThresholdInBytes',3.0.0], [spark.sql.adaptive.skewJoin.skewedPartitionThresholdInBytes,256MB,A partition is considered as skewed if its size in bytes is larger than this threshold and also larger than 'spark.sql.adaptive.skewJoin.skewedPartitionFactor' multiplying the median partition size. Ideally this config should be set larger than 'spark.sql.adaptive.advisoryPartitionSizeInBytes'.,3.0.0], [spark.sql.allowNamedFunctionArguments,true,If true, Spark will turn on support for named parameters for all functions that has it implemented.,3.5.0], [spark.sql.ansi.doubleQuotedIdentifiers,false,When true and 'spark.sql.ansi.enabled' is true, Spark SQL reads literals enclosed in double quoted (") as identifiers. When false they are read as string literals.,3.4.0], [spark.sql.ansi.enabled,false,When true, Spark SQL uses an ANSI compliant dialect instead of being Hive compliant. For example, Spark will throw an exception at runtime instead of returning null results when the inputs to a SQL operator/function are invalid.For full details of this dialect, you can find them in the section "ANSI Compliance" of Spark's documentation. Some ANSI dialect features may be not from the ANSI SQL standard directly, but their behaviors align with ANSI SQL's style,3.0.0], [spark.sql.ansi.enforceReservedKeywords,false,When true and 'spark.sql.ansi.enabled' is true, the Spark SQL parser enforces the ANSI reserved keywords and forbids SQL queries that use reserved keywords as alias names and/or identifiers for table, view, function, etc.,3.3.0], [spark.sql.ansi.relationPrecedence,false,When true and 'spark.sql.ansi.enabled' is true, JOIN takes precedence over comma when combining relation. For example, `t1, t2 JOIN t3` should result to `t1 X (t2 X t3)`. If the config is false, the result is `(t1 X t2) X t3`.,3.4.0], [spark.sql.autoBroadcastJoinThreshold,10MB,Configures the maximum size in bytes for a table that will be broadcast to all worker nodes when performing a join.  By setting this value to -1 broadcasting can be disabled. Note that currently statistics are only supported for Hive Metastore tables where the command `ANALYZE TABLE <tableName> COMPUTE STATISTICS noscan` has been run, and file-based data source tables where the statistics are computed directly on the files of data.,1.1.0], [spark.sql.avro.compression.codec,snappy,Compression codec used in writing of AVRO files. Supported codecs: uncompressed, deflate, snappy, bzip2, xz and zstandard. Default codec is snappy.,2.4.0], ... 183 more fields]
   +- SetCommand (-v,None)

== Physical Plan ==
CommandResult [key#5567, value#5568, meaning#5569, Since version#5570]
   +- Execute SetCommand
         +- SetCommand (-v,None)

== Parsed Logical Plan ==
'GlobalLimit 5
+- 'LocalLimit 5
   +- 'Sort ['C_25 DESC NULLS LAST], true
      +- 'Project ['C_43 AS C_12#5510, 'C_2 AS C_13#5511, 'C_4 AS C_14#5512, 'C_4331 AS C_17#5513, 'C_4332 AS C_16#5514, 'C_4333 AS C_18#5515, 'C_8 AS C_19#5516, 'C_5 AS C_15#5517, 'C_9 AS C_20#5518, 'C_6 AS C_24#5519, 'C_7 AS C_21#5520, 'C_11 AS C_23#5521, 'C_10 AS C_22#5522, 'C_0 AS C_25#5523]
         +- 'SubqueryAlias C_4954424c
            +- 'Project ['C_64656661756c745f616972706f727473.id AS C_43#5494, 'C_64656661756c745f616972706f727473.type AS C_2#5495, 'C_64656661756c745f616972706f727473.name AS C_4#5496, 'C_64656661756c745f616972706f727473.lat AS C_1#5497, 'C_64656661756c745f616972706f727473.lon AS C_3#5498, 'C_64656661756c745f616972706f727473.elev AS C_0#5499, 'C_64656661756c745f616972706f727473.continent AS C_8#5500, 'C_64656661756c745f616972706f727473.country AS C_5#5501, 'C_64656661756c745f616972706f727473.region AS C_9#5502, 'C_64656661756c745f616972706f727473.city AS C_6#5503, 'C_64656661756c745f616972706f727473.iata AS C_7#5504, 'C_64656661756c745f616972706f727473.code AS C_11#5505, 'C_64656661756c745f616972706f727473.gps AS C_10#5506, ('round(('C_64656661756c745f616972706f727473.lat * 'power(10.0, 3)), 0) / 'power(10.0, 3)) AS C_4331#5507, ('round(('C_64656661756c745f616972706f727473.lon * 'power(10.0, 3)), 0) / 'power(10.0, 3)) AS C_4332#5508, ('round(('C_64656661756c745f616972706f727473.elev * 'power(10.0, 3)), 0) / 'power(10.0, 3)) AS C_4333#5509]
               +- 'Filter ((('C_64656661756c745f616972706f727473.lon <= -104.05) AND ('C_64656661756c745f616972706f727473.lon >= -111.05)) AND (('C_64656661756c745f616972706f727473.lat >= 41.0) AND ('C_64656661756c745f616972706f727473.lat <= 45.0)))
                  +- 'SubqueryAlias C_64656661756c745f616972706f727473
                     +- 'UnresolvedRelation [default, airports], [], false

== Analyzed Logical Plan ==
C_12: string, C_13: string, C_14: string, C_17: double, C_16: double, C_18: double, C_19: string, C_15: string, C_20: string, C_24: string, C_21: string, C_23: string, C_22: string, C_25: double
GlobalLimit 5
+- LocalLimit 5
   +- Sort [C_25#5523 DESC NULLS LAST], true
      +- Project [C_43#5494 AS C_12#5510, C_2#5495 AS C_13#5511, C_4#5496 AS C_14#5512, C_4331#5507 AS C_17#5513, C_4332#5508 AS C_16#5514, C_4333#5509 AS C_18#5515, C_8#5500 AS C_19#5516, C_5#5501 AS C_15#5517, C_9#5502 AS C_20#5518, C_6#5503 AS C_24#5519, C_7#5504 AS C_21#5520, C_11#5505 AS C_23#5521, C_10#5506 AS C_22#5522, C_0#5499 AS C_25#5523]
         +- SubqueryAlias C_4954424c
            +- Project [id#5524 AS C_43#5494, type#5525 AS C_2#5495, name#5526 AS C_4#5496, lat#5527 AS C_1#5497, lon#5528 AS C_3#5498, elev#5529 AS C_0#5499, continent#5530 AS C_8#5500, country#5531 AS C_5#5501, region#5532 AS C_9#5502, city#5533 AS C_6#5503, iata#5534 AS C_7#5504, code#5535 AS C_11#5505, gps#5536 AS C_10#5506, (round((lat#5527 * POWER(10.0, cast(3 as double))), 0) / POWER(10.0, cast(3 as double))) AS C_4331#5507, (round((lon#5528 * POWER(10.0, cast(3 as double))), 0) / POWER(10.0, cast(3 as double))) AS C_4332#5508, (round((elev#5529 * POWER(10.0, cast(3 as double))), 0) / POWER(10.0, cast(3 as double))) AS C_4333#5509]
               +- Filter (((lon#5528 <= -104.05) AND (lon#5528 >= -111.05)) AND ((lat#5527 >= 41.0) AND (lat#5527 <= 45.0)))
                  +- SubqueryAlias C_64656661756c745f616972706f727473
                     +- SubqueryAlias spark_catalog.default.airports
                        +- Relation spark_catalog.default.airports[id#5524,type#5525,name#5526,lat#5527,lon#5528,elev#5529,continent#5530,country#5531,region#5532,city#5533,iata#5534,code#5535,gps#5536] parquet

== Optimized Logical Plan ==
GlobalLimit 5
+- LocalLimit 5
   +- Sort [C_25#5523 DESC NULLS LAST], true
      +- Project [id#5524 AS C_12#5510, type#5525 AS C_13#5511, name#5526 AS C_14#5512, (round((lat#5527 * 1000.0), 0) / 1000.0) AS C_17#5513, (round((lon#5528 * 1000.0), 0) / 1000.0) AS C_16#5514, (round((elev#5529 * 1000.0), 0) / 1000.0) AS C_18#5515, continent#5530 AS C_19#5516, country#5531 AS C_15#5517, region#5532 AS C_20#5518, city#5533 AS C_24#5519, iata#5534 AS C_21#5520, code#5535 AS C_23#5521, gps#5536 AS C_22#5522, elev#5529 AS C_25#5523]
         +- Filter ((isnotnull(lon#5528) AND isnotnull(lat#5527)) AND (((lon#5528 <= -104.05) AND (lon#5528 >= -111.05)) AND ((lat#5527 >= 41.0) AND (lat#5527 <= 45.0))))
            +- Relation spark_catalog.default.airports[id#5524,type#5525,name#5526,lat#5527,lon#5528,elev#5529,continent#5530,country#5531,region#5532,city#5533,iata#5534,code#5535,gps#5536] parquet

== Physical Plan ==
TakeOrderedAndProject(limit=5, orderBy=[C_25#5523 DESC NULLS LAST], output=[C_12#5510,C_13#5511,C_14#5512,C_17#5513,C_16#5514,C_18#5515,C_19#5516,C_15#5517,C_20#5518,C_24#5519,C_21#5520,C_23#5521,C_22#5522,C_25#5523])
+- *(1) Project [id#5524 AS C_12#5510, type#5525 AS C_13#5511, name#5526 AS C_14#5512, (round((lat#5527 * 1000.0), 0) / 1000.0) AS C_17#5513, (round((lon#5528 * 1000.0), 0) / 1000.0) AS C_16#5514, (round((elev#5529 * 1000.0), 0) / 1000.0) AS C_18#5515, continent#5530 AS C_19#5516, country#5531 AS C_15#5517, region#5532 AS C_20#5518, city#5533 AS C_24#5519, iata#5534 AS C_21#5520, code#5535 AS C_23#5521, gps#5536 AS C_22#5522, elev#5529 AS C_25#5523]
   +- *(1) Filter (((((isnotnull(lon#5528) AND isnotnull(lat#5527)) AND (lon#5528 <= -104.05)) AND (lon#5528 >= -111.05)) AND (lat#5527 >= 41.0)) AND (lat#5527 <= 45.0))
      +- *(1) ColumnarToRow
         +- FileScan parquet spark_catalog.default.airports[id#5524,type#5525,name#5526,lat#5527,lon#5528,elev#5529,continent#5530,country#5531,region#5532,city#5533,iata#5534,code#5535,gps#5536] Batched: true, DataFilters: [isnotnull(lon#5528), isnotnull(lat#5527), (lon#5528 <= -104.05), (lon#5528 >= -111.05), (lat#552..., Format: Parquet, Location: InMemoryFileIndex(1 paths)[file:/home/acdcadmin/spark-warehouse/airports], PartitionFilters: [], PushedFilters: [IsNotNull(lon), IsNotNull(lat), LessThanOrEqual(lon,-104.05), GreaterThanOrEqual(lon,-111.05), G..., ReadSchema: struct<id:string,type:string,name:string,lat:double,lon:double,elev:double,continent:string,count...

== Parsed Logical Plan ==
'DescribeRelation false, [col_name#5471, data_type#5472, comment#5473]
+- 'UnresolvedTableOrView [default, airports], DESCRIBE TABLE, true

== Analyzed Logical Plan ==
col_name: string, data_type: string, comment: string
DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#5471, data_type#5472, comment#5473]

== Optimized Logical Plan ==
CommandResult [col_name#5471, data_type#5472, comment#5473], Execute DescribeTableCommand, [[id,string,null], [type,string,null], [name,string,null], [lat,double,null], [lon,double,null], [elev,double,null], [continent,string,null], [country,string,null], [region,string,null], [city,string,null], [iata,string,null], [code,string,null], [gps,string,null]]
   +- DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#5471, data_type#5472, comment#5473]

== Physical Plan ==
CommandResult [col_name#5471, data_type#5472, comment#5473]
   +- Execute DescribeTableCommand
         +- DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#5471, data_type#5472, comment#5473]

== Parsed Logical Plan ==
'DescribeRelation false, [col_name#5448, data_type#5449, comment#5450]
+- 'UnresolvedTableOrView [default, airports], DESCRIBE TABLE, true

== Analyzed Logical Plan ==
col_name: string, data_type: string, comment: string
DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#5448, data_type#5449, comment#5450]

== Optimized Logical Plan ==
CommandResult [col_name#5448, data_type#5449, comment#5450], Execute DescribeTableCommand, [[id,string,null], [type,string,null], [name,string,null], [lat,double,null], [lon,double,null], [elev,double,null], [continent,string,null], [country,string,null], [region,string,null], [city,string,null], [iata,string,null], [code,string,null], [gps,string,null]]
   +- DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#5448, data_type#5449, comment#5450]

== Physical Plan ==
CommandResult [col_name#5448, data_type#5449, comment#5450]
   +- Execute DescribeTableCommand
         +- DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#5448, data_type#5449, comment#5450]

== Parsed Logical Plan ==
SetCommand (-v,None)

== Analyzed Logical Plan ==
key: string, value: string, meaning: string, Since version: string
SetCommand (-v,None)

== Optimized Logical Plan ==
CommandResult [key#5423, value#5424, meaning#5425, Since version#5426], Execute SetCommand, [[spark.sql.adaptive.advisoryPartitionSizeInBytes,<value of spark.sql.adaptive.shuffle.targetPostShuffleInputSize>,The advisory size in bytes of the shuffle partition during adaptive optimization (when spark.sql.adaptive.enabled is true). It takes effect when Spark coalesces small shuffle partitions or splits skewed shuffle partition.,3.0.0], [spark.sql.adaptive.autoBroadcastJoinThreshold,<undefined>,Configures the maximum size in bytes for a table that will be broadcast to all worker nodes when performing a join. By setting this value to -1 broadcasting can be disabled. The default value is same with spark.sql.autoBroadcastJoinThreshold. Note that, this config is used only in adaptive framework.,3.2.0], [spark.sql.adaptive.coalescePartitions.enabled,true,When true and 'spark.sql.adaptive.enabled' is true, Spark will coalesce contiguous shuffle partitions according to the target size (specified by 'spark.sql.adaptive.advisoryPartitionSizeInBytes'), to avoid too many small tasks.,3.0.0], [spark.sql.adaptive.coalescePartitions.initialPartitionNum,<undefined>,The initial number of shuffle partitions before coalescing. If not set, it equals to spark.sql.shuffle.partitions. This configuration only has an effect when 'spark.sql.adaptive.enabled' and 'spark.sql.adaptive.coalescePartitions.enabled' are both true.,3.0.0], [spark.sql.adaptive.coalescePartitions.minPartitionSize,1MB,The minimum size of shuffle partitions after coalescing. This is useful when the adaptively calculated target size is too small during partition coalescing.,3.2.0], [spark.sql.adaptive.coalescePartitions.parallelismFirst,true,When true, Spark does not respect the target size specified by 'spark.sql.adaptive.advisoryPartitionSizeInBytes' (default 64MB) when coalescing contiguous shuffle partitions, but adaptively calculate the target size according to the default parallelism of the Spark cluster. The calculated size is usually smaller than the configured target size. This is to maximize the parallelism and avoid performance regression when enabling adaptive query execution. It's recommended to set this config to false and respect the configured target size.,3.2.0], [spark.sql.adaptive.customCostEvaluatorClass,<undefined>,The custom cost evaluator class to be used for adaptive execution. If not being set, Spark will use its own SimpleCostEvaluator by default.,3.2.0], [spark.sql.adaptive.enabled,true,When true, enable adaptive query execution, which re-optimizes the query plan in the middle of query execution, based on accurate runtime statistics.,1.6.0], [spark.sql.adaptive.forceOptimizeSkewedJoin,false,When true, force enable OptimizeSkewedJoin even if it introduces extra shuffle.,3.3.0], [spark.sql.adaptive.localShuffleReader.enabled,true,When true and 'spark.sql.adaptive.enabled' is true, Spark tries to use local shuffle reader to read the shuffle data when the shuffle partitioning is not needed, for example, after converting sort-merge join to broadcast-hash join.,3.0.0], [spark.sql.adaptive.maxShuffledHashJoinLocalMapThreshold,0b,Configures the maximum size in bytes per partition that can be allowed to build local hash map. If this value is not smaller than spark.sql.adaptive.advisoryPartitionSizeInBytes and all the partition size are not larger than this config, join selection prefer to use shuffled hash join instead of sort merge join regardless of the value of spark.sql.join.preferSortMergeJoin.,3.2.0], [spark.sql.adaptive.optimizeSkewsInRebalancePartitions.enabled,true,When true and 'spark.sql.adaptive.enabled' is true, Spark will optimize the skewed shuffle partitions in RebalancePartitions and split them to smaller ones according to the target size (specified by 'spark.sql.adaptive.advisoryPartitionSizeInBytes'), to avoid data skew.,3.2.0], [spark.sql.adaptive.optimizer.excludedRules,<undefined>,Configures a list of rules to be disabled in the adaptive optimizer, in which the rules are specified by their rule names and separated by comma. The optimizer will log the rules that have indeed been excluded.,3.1.0], [spark.sql.adaptive.rebalancePartitionsSmallPartitionFactor,0.2,A partition will be merged during splitting if its size is small than this factor multiply spark.sql.adaptive.advisoryPartitionSizeInBytes.,3.3.0], [spark.sql.adaptive.skewJoin.enabled,true,When true and 'spark.sql.adaptive.enabled' is true, Spark dynamically handles skew in shuffled join (sort-merge and shuffled hash) by splitting (and replicating if needed) skewed partitions.,3.0.0], [spark.sql.adaptive.skewJoin.skewedPartitionFactor,5.0,A partition is considered as skewed if its size is larger than this factor multiplying the median partition size and also larger than 'spark.sql.adaptive.skewJoin.skewedPartitionThresholdInBytes',3.0.0], [spark.sql.adaptive.skewJoin.skewedPartitionThresholdInBytes,256MB,A partition is considered as skewed if its size in bytes is larger than this threshold and also larger than 'spark.sql.adaptive.skewJoin.skewedPartitionFactor' multiplying the median partition size. Ideally this config should be set larger than 'spark.sql.adaptive.advisoryPartitionSizeInBytes'.,3.0.0], [spark.sql.allowNamedFunctionArguments,true,If true, Spark will turn on support for named parameters for all functions that has it implemented.,3.5.0], [spark.sql.ansi.doubleQuotedIdentifiers,false,When true and 'spark.sql.ansi.enabled' is true, Spark SQL reads literals enclosed in double quoted (") as identifiers. When false they are read as string literals.,3.4.0], [spark.sql.ansi.enabled,false,When true, Spark SQL uses an ANSI compliant dialect instead of being Hive compliant. For example, Spark will throw an exception at runtime instead of returning null results when the inputs to a SQL operator/function are invalid.For full details of this dialect, you can find them in the section "ANSI Compliance" of Spark's documentation. Some ANSI dialect features may be not from the ANSI SQL standard directly, but their behaviors align with ANSI SQL's style,3.0.0], [spark.sql.ansi.enforceReservedKeywords,false,When true and 'spark.sql.ansi.enabled' is true, the Spark SQL parser enforces the ANSI reserved keywords and forbids SQL queries that use reserved keywords as alias names and/or identifiers for table, view, function, etc.,3.3.0], [spark.sql.ansi.relationPrecedence,false,When true and 'spark.sql.ansi.enabled' is true, JOIN takes precedence over comma when combining relation. For example, `t1, t2 JOIN t3` should result to `t1 X (t2 X t3)`. If the config is false, the result is `(t1 X t2) X t3`.,3.4.0], [spark.sql.autoBroadcastJoinThreshold,10MB,Configures the maximum size in bytes for a table that will be broadcast to all worker nodes when performing a join.  By setting this value to -1 broadcasting can be disabled. Note that currently statistics are only supported for Hive Metastore tables where the command `ANALYZE TABLE <tableName> COMPUTE STATISTICS noscan` has been run, and file-based data source tables where the statistics are computed directly on the files of data.,1.1.0], [spark.sql.avro.compression.codec,snappy,Compression codec used in writing of AVRO files. Supported codecs: uncompressed, deflate, snappy, bzip2, xz and zstandard. Default codec is snappy.,2.4.0], ... 183 more fields]
   +- SetCommand (-v,None)

== Physical Plan ==
CommandResult [key#5423, value#5424, meaning#5425, Since version#5426]
   +- Execute SetCommand
         +- SetCommand (-v,None)

== Parsed Logical Plan ==
'GlobalLimit 5
+- 'LocalLimit 5
   +- 'Sort ['C_15 DESC NULLS LAST], true
      +- 'Project ['C_43 AS C_13#5366, 'C_0 AS C_12#5367, 'C_8 AS C_18#5368, 'C_4331 AS C_21#5369, 'C_4332 AS C_17#5370, 'C_4333 AS C_20#5371, 'C_4 AS C_22#5372, 'C_5 AS C_25#5373, 'C_6 AS C_23#5374, 'C_7 AS C_14#5375, 'C_9 AS C_24#5376, 'C_11 AS C_16#5377, 'C_10 AS C_19#5378, 'C_2 AS C_15#5379]
         +- 'SubqueryAlias C_4954424c
            +- 'Project ['C_64656661756c745f616972706f727473.id AS C_43#5350, 'C_64656661756c745f616972706f727473.type AS C_0#5351, 'C_64656661756c745f616972706f727473.name AS C_8#5352, 'C_64656661756c745f616972706f727473.lat AS C_3#5353, 'C_64656661756c745f616972706f727473.lon AS C_1#5354, 'C_64656661756c745f616972706f727473.elev AS C_2#5355, 'C_64656661756c745f616972706f727473.continent AS C_4#5356, 'C_64656661756c745f616972706f727473.country AS C_5#5357, 'C_64656661756c745f616972706f727473.region AS C_6#5358, 'C_64656661756c745f616972706f727473.city AS C_7#5359, 'C_64656661756c745f616972706f727473.iata AS C_9#5360, 'C_64656661756c745f616972706f727473.code AS C_11#5361, 'C_64656661756c745f616972706f727473.gps AS C_10#5362, ('round(('C_64656661756c745f616972706f727473.lat * 'power(10.0, 3)), 0) / 'power(10.0, 3)) AS C_4331#5363, ('round(('C_64656661756c745f616972706f727473.lon * 'power(10.0, 3)), 0) / 'power(10.0, 3)) AS C_4332#5364, ('round(('C_64656661756c745f616972706f727473.elev * 'power(10.0, 3)), 0) / 'power(10.0, 3)) AS C_4333#5365]
               +- 'Filter ((('C_64656661756c745f616972706f727473.lon <= -104.05) AND ('C_64656661756c745f616972706f727473.lon >= -111.05)) AND (('C_64656661756c745f616972706f727473.lat >= 41.0) AND ('C_64656661756c745f616972706f727473.lat <= 45.0)))
                  +- 'SubqueryAlias C_64656661756c745f616972706f727473
                     +- 'UnresolvedRelation [default, airports], [], false

== Analyzed Logical Plan ==
C_13: string, C_12: string, C_18: string, C_21: double, C_17: double, C_20: double, C_22: string, C_25: string, C_23: string, C_14: string, C_24: string, C_16: string, C_19: string, C_15: double
GlobalLimit 5
+- LocalLimit 5
   +- Sort [C_15#5379 DESC NULLS LAST], true
      +- Project [C_43#5350 AS C_13#5366, C_0#5351 AS C_12#5367, C_8#5352 AS C_18#5368, C_4331#5363 AS C_21#5369, C_4332#5364 AS C_17#5370, C_4333#5365 AS C_20#5371, C_4#5356 AS C_22#5372, C_5#5357 AS C_25#5373, C_6#5358 AS C_23#5374, C_7#5359 AS C_14#5375, C_9#5360 AS C_24#5376, C_11#5361 AS C_16#5377, C_10#5362 AS C_19#5378, C_2#5355 AS C_15#5379]
         +- SubqueryAlias C_4954424c
            +- Project [id#5380 AS C_43#5350, type#5381 AS C_0#5351, name#5382 AS C_8#5352, lat#5383 AS C_3#5353, lon#5384 AS C_1#5354, elev#5385 AS C_2#5355, continent#5386 AS C_4#5356, country#5387 AS C_5#5357, region#5388 AS C_6#5358, city#5389 AS C_7#5359, iata#5390 AS C_9#5360, code#5391 AS C_11#5361, gps#5392 AS C_10#5362, (round((lat#5383 * POWER(10.0, cast(3 as double))), 0) / POWER(10.0, cast(3 as double))) AS C_4331#5363, (round((lon#5384 * POWER(10.0, cast(3 as double))), 0) / POWER(10.0, cast(3 as double))) AS C_4332#5364, (round((elev#5385 * POWER(10.0, cast(3 as double))), 0) / POWER(10.0, cast(3 as double))) AS C_4333#5365]
               +- Filter (((lon#5384 <= -104.05) AND (lon#5384 >= -111.05)) AND ((lat#5383 >= 41.0) AND (lat#5383 <= 45.0)))
                  +- SubqueryAlias C_64656661756c745f616972706f727473
                     +- SubqueryAlias spark_catalog.default.airports
                        +- Relation spark_catalog.default.airports[id#5380,type#5381,name#5382,lat#5383,lon#5384,elev#5385,continent#5386,country#5387,region#5388,city#5389,iata#5390,code#5391,gps#5392] parquet

== Optimized Logical Plan ==
GlobalLimit 5
+- LocalLimit 5
   +- Sort [C_15#5379 DESC NULLS LAST], true
      +- Project [id#5380 AS C_13#5366, type#5381 AS C_12#5367, name#5382 AS C_18#5368, (round((lat#5383 * 1000.0), 0) / 1000.0) AS C_21#5369, (round((lon#5384 * 1000.0), 0) / 1000.0) AS C_17#5370, (round((elev#5385 * 1000.0), 0) / 1000.0) AS C_20#5371, continent#5386 AS C_22#5372, country#5387 AS C_25#5373, region#5388 AS C_23#5374, city#5389 AS C_14#5375, iata#5390 AS C_24#5376, code#5391 AS C_16#5377, gps#5392 AS C_19#5378, elev#5385 AS C_15#5379]
         +- Filter ((isnotnull(lon#5384) AND isnotnull(lat#5383)) AND (((lon#5384 <= -104.05) AND (lon#5384 >= -111.05)) AND ((lat#5383 >= 41.0) AND (lat#5383 <= 45.0))))
            +- Relation spark_catalog.default.airports[id#5380,type#5381,name#5382,lat#5383,lon#5384,elev#5385,continent#5386,country#5387,region#5388,city#5389,iata#5390,code#5391,gps#5392] parquet

== Physical Plan ==
TakeOrderedAndProject(limit=5, orderBy=[C_15#5379 DESC NULLS LAST], output=[C_13#5366,C_12#5367,C_18#5368,C_21#5369,C_17#5370,C_20#5371,C_22#5372,C_25#5373,C_23#5374,C_14#5375,C_24#5376,C_16#5377,C_19#5378,C_15#5379])
+- *(1) Project [id#5380 AS C_13#5366, type#5381 AS C_12#5367, name#5382 AS C_18#5368, (round((lat#5383 * 1000.0), 0) / 1000.0) AS C_21#5369, (round((lon#5384 * 1000.0), 0) / 1000.0) AS C_17#5370, (round((elev#5385 * 1000.0), 0) / 1000.0) AS C_20#5371, continent#5386 AS C_22#5372, country#5387 AS C_25#5373, region#5388 AS C_23#5374, city#5389 AS C_14#5375, iata#5390 AS C_24#5376, code#5391 AS C_16#5377, gps#5392 AS C_19#5378, elev#5385 AS C_15#5379]
   +- *(1) Filter (((((isnotnull(lon#5384) AND isnotnull(lat#5383)) AND (lon#5384 <= -104.05)) AND (lon#5384 >= -111.05)) AND (lat#5383 >= 41.0)) AND (lat#5383 <= 45.0))
      +- *(1) ColumnarToRow
         +- FileScan parquet spark_catalog.default.airports[id#5380,type#5381,name#5382,lat#5383,lon#5384,elev#5385,continent#5386,country#5387,region#5388,city#5389,iata#5390,code#5391,gps#5392] Batched: true, DataFilters: [isnotnull(lon#5384), isnotnull(lat#5383), (lon#5384 <= -104.05), (lon#5384 >= -111.05), (lat#538..., Format: Parquet, Location: InMemoryFileIndex(1 paths)[file:/home/acdcadmin/spark-warehouse/airports], PartitionFilters: [], PushedFilters: [IsNotNull(lon), IsNotNull(lat), LessThanOrEqual(lon,-104.05), GreaterThanOrEqual(lon,-111.05), G..., ReadSchema: struct<id:string,type:string,name:string,lat:double,lon:double,elev:double,continent:string,count...

== Parsed Logical Plan ==
'DescribeRelation false, [col_name#5327, data_type#5328, comment#5329]
+- 'UnresolvedTableOrView [default, airports], DESCRIBE TABLE, true

== Analyzed Logical Plan ==
col_name: string, data_type: string, comment: string
DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#5327, data_type#5328, comment#5329]

== Optimized Logical Plan ==
CommandResult [col_name#5327, data_type#5328, comment#5329], Execute DescribeTableCommand, [[id,string,null], [type,string,null], [name,string,null], [lat,double,null], [lon,double,null], [elev,double,null], [continent,string,null], [country,string,null], [region,string,null], [city,string,null], [iata,string,null], [code,string,null], [gps,string,null]]
   +- DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#5327, data_type#5328, comment#5329]

== Physical Plan ==
CommandResult [col_name#5327, data_type#5328, comment#5329]
   +- Execute DescribeTableCommand
         +- DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#5327, data_type#5328, comment#5329]

== Parsed Logical Plan ==
'DescribeRelation false, [col_name#5304, data_type#5305, comment#5306]
+- 'UnresolvedTableOrView [default, airports], DESCRIBE TABLE, true

== Analyzed Logical Plan ==
col_name: string, data_type: string, comment: string
DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#5304, data_type#5305, comment#5306]

== Optimized Logical Plan ==
CommandResult [col_name#5304, data_type#5305, comment#5306], Execute DescribeTableCommand, [[id,string,null], [type,string,null], [name,string,null], [lat,double,null], [lon,double,null], [elev,double,null], [continent,string,null], [country,string,null], [region,string,null], [city,string,null], [iata,string,null], [code,string,null], [gps,string,null]]
   +- DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#5304, data_type#5305, comment#5306]

== Physical Plan ==
CommandResult [col_name#5304, data_type#5305, comment#5306]
   +- Execute DescribeTableCommand
         +- DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#5304, data_type#5305, comment#5306]

== Parsed Logical Plan ==
SetCommand (-v,None)

== Analyzed Logical Plan ==
key: string, value: string, meaning: string, Since version: string
SetCommand (-v,None)

== Optimized Logical Plan ==
CommandResult [key#5279, value#5280, meaning#5281, Since version#5282], Execute SetCommand, [[spark.sql.adaptive.advisoryPartitionSizeInBytes,<value of spark.sql.adaptive.shuffle.targetPostShuffleInputSize>,The advisory size in bytes of the shuffle partition during adaptive optimization (when spark.sql.adaptive.enabled is true). It takes effect when Spark coalesces small shuffle partitions or splits skewed shuffle partition.,3.0.0], [spark.sql.adaptive.autoBroadcastJoinThreshold,<undefined>,Configures the maximum size in bytes for a table that will be broadcast to all worker nodes when performing a join. By setting this value to -1 broadcasting can be disabled. The default value is same with spark.sql.autoBroadcastJoinThreshold. Note that, this config is used only in adaptive framework.,3.2.0], [spark.sql.adaptive.coalescePartitions.enabled,true,When true and 'spark.sql.adaptive.enabled' is true, Spark will coalesce contiguous shuffle partitions according to the target size (specified by 'spark.sql.adaptive.advisoryPartitionSizeInBytes'), to avoid too many small tasks.,3.0.0], [spark.sql.adaptive.coalescePartitions.initialPartitionNum,<undefined>,The initial number of shuffle partitions before coalescing. If not set, it equals to spark.sql.shuffle.partitions. This configuration only has an effect when 'spark.sql.adaptive.enabled' and 'spark.sql.adaptive.coalescePartitions.enabled' are both true.,3.0.0], [spark.sql.adaptive.coalescePartitions.minPartitionSize,1MB,The minimum size of shuffle partitions after coalescing. This is useful when the adaptively calculated target size is too small during partition coalescing.,3.2.0], [spark.sql.adaptive.coalescePartitions.parallelismFirst,true,When true, Spark does not respect the target size specified by 'spark.sql.adaptive.advisoryPartitionSizeInBytes' (default 64MB) when coalescing contiguous shuffle partitions, but adaptively calculate the target size according to the default parallelism of the Spark cluster. The calculated size is usually smaller than the configured target size. This is to maximize the parallelism and avoid performance regression when enabling adaptive query execution. It's recommended to set this config to false and respect the configured target size.,3.2.0], [spark.sql.adaptive.customCostEvaluatorClass,<undefined>,The custom cost evaluator class to be used for adaptive execution. If not being set, Spark will use its own SimpleCostEvaluator by default.,3.2.0], [spark.sql.adaptive.enabled,true,When true, enable adaptive query execution, which re-optimizes the query plan in the middle of query execution, based on accurate runtime statistics.,1.6.0], [spark.sql.adaptive.forceOptimizeSkewedJoin,false,When true, force enable OptimizeSkewedJoin even if it introduces extra shuffle.,3.3.0], [spark.sql.adaptive.localShuffleReader.enabled,true,When true and 'spark.sql.adaptive.enabled' is true, Spark tries to use local shuffle reader to read the shuffle data when the shuffle partitioning is not needed, for example, after converting sort-merge join to broadcast-hash join.,3.0.0], [spark.sql.adaptive.maxShuffledHashJoinLocalMapThreshold,0b,Configures the maximum size in bytes per partition that can be allowed to build local hash map. If this value is not smaller than spark.sql.adaptive.advisoryPartitionSizeInBytes and all the partition size are not larger than this config, join selection prefer to use shuffled hash join instead of sort merge join regardless of the value of spark.sql.join.preferSortMergeJoin.,3.2.0], [spark.sql.adaptive.optimizeSkewsInRebalancePartitions.enabled,true,When true and 'spark.sql.adaptive.enabled' is true, Spark will optimize the skewed shuffle partitions in RebalancePartitions and split them to smaller ones according to the target size (specified by 'spark.sql.adaptive.advisoryPartitionSizeInBytes'), to avoid data skew.,3.2.0], [spark.sql.adaptive.optimizer.excludedRules,<undefined>,Configures a list of rules to be disabled in the adaptive optimizer, in which the rules are specified by their rule names and separated by comma. The optimizer will log the rules that have indeed been excluded.,3.1.0], [spark.sql.adaptive.rebalancePartitionsSmallPartitionFactor,0.2,A partition will be merged during splitting if its size is small than this factor multiply spark.sql.adaptive.advisoryPartitionSizeInBytes.,3.3.0], [spark.sql.adaptive.skewJoin.enabled,true,When true and 'spark.sql.adaptive.enabled' is true, Spark dynamically handles skew in shuffled join (sort-merge and shuffled hash) by splitting (and replicating if needed) skewed partitions.,3.0.0], [spark.sql.adaptive.skewJoin.skewedPartitionFactor,5.0,A partition is considered as skewed if its size is larger than this factor multiplying the median partition size and also larger than 'spark.sql.adaptive.skewJoin.skewedPartitionThresholdInBytes',3.0.0], [spark.sql.adaptive.skewJoin.skewedPartitionThresholdInBytes,256MB,A partition is considered as skewed if its size in bytes is larger than this threshold and also larger than 'spark.sql.adaptive.skewJoin.skewedPartitionFactor' multiplying the median partition size. Ideally this config should be set larger than 'spark.sql.adaptive.advisoryPartitionSizeInBytes'.,3.0.0], [spark.sql.allowNamedFunctionArguments,true,If true, Spark will turn on support for named parameters for all functions that has it implemented.,3.5.0], [spark.sql.ansi.doubleQuotedIdentifiers,false,When true and 'spark.sql.ansi.enabled' is true, Spark SQL reads literals enclosed in double quoted (") as identifiers. When false they are read as string literals.,3.4.0], [spark.sql.ansi.enabled,false,When true, Spark SQL uses an ANSI compliant dialect instead of being Hive compliant. For example, Spark will throw an exception at runtime instead of returning null results when the inputs to a SQL operator/function are invalid.For full details of this dialect, you can find them in the section "ANSI Compliance" of Spark's documentation. Some ANSI dialect features may be not from the ANSI SQL standard directly, but their behaviors align with ANSI SQL's style,3.0.0], [spark.sql.ansi.enforceReservedKeywords,false,When true and 'spark.sql.ansi.enabled' is true, the Spark SQL parser enforces the ANSI reserved keywords and forbids SQL queries that use reserved keywords as alias names and/or identifiers for table, view, function, etc.,3.3.0], [spark.sql.ansi.relationPrecedence,false,When true and 'spark.sql.ansi.enabled' is true, JOIN takes precedence over comma when combining relation. For example, `t1, t2 JOIN t3` should result to `t1 X (t2 X t3)`. If the config is false, the result is `(t1 X t2) X t3`.,3.4.0], [spark.sql.autoBroadcastJoinThreshold,10MB,Configures the maximum size in bytes for a table that will be broadcast to all worker nodes when performing a join.  By setting this value to -1 broadcasting can be disabled. Note that currently statistics are only supported for Hive Metastore tables where the command `ANALYZE TABLE <tableName> COMPUTE STATISTICS noscan` has been run, and file-based data source tables where the statistics are computed directly on the files of data.,1.1.0], [spark.sql.avro.compression.codec,snappy,Compression codec used in writing of AVRO files. Supported codecs: uncompressed, deflate, snappy, bzip2, xz and zstandard. Default codec is snappy.,2.4.0], ... 183 more fields]
   +- SetCommand (-v,None)

== Physical Plan ==
CommandResult [key#5279, value#5280, meaning#5281, Since version#5282]
   +- Execute SetCommand
         +- SetCommand (-v,None)

== Parsed Logical Plan ==
'GlobalLimit 5
+- 'LocalLimit 5
   +- 'Sort ['C_17 DESC NULLS LAST], true
      +- 'Project ['C_10 AS C_13#5222, 'C_43 AS C_18#5223, 'C_4 AS C_23#5224, 'C_4331 AS C_16#5225, 'C_4332 AS C_21#5226, 'C_4333 AS C_22#5227, 'C_7 AS C_20#5228, 'C_2 AS C_15#5229, 'C_5 AS C_25#5230, 'C_8 AS C_12#5231, 'C_9 AS C_24#5232, 'C_3 AS C_14#5233, 'C_11 AS C_19#5234, 'C_1 AS C_17#5235]
         +- 'SubqueryAlias C_4954424c
            +- 'Project ['C_64656661756c745f616972706f727473.id AS C_10#5206, 'C_64656661756c745f616972706f727473.type AS C_43#5207, 'C_64656661756c745f616972706f727473.name AS C_4#5208, 'C_64656661756c745f616972706f727473.lat AS C_0#5209, 'C_64656661756c745f616972706f727473.lon AS C_6#5210, 'C_64656661756c745f616972706f727473.elev AS C_1#5211, 'C_64656661756c745f616972706f727473.continent AS C_7#5212, 'C_64656661756c745f616972706f727473.country AS C_2#5213, 'C_64656661756c745f616972706f727473.region AS C_5#5214, 'C_64656661756c745f616972706f727473.city AS C_8#5215, 'C_64656661756c745f616972706f727473.iata AS C_9#5216, 'C_64656661756c745f616972706f727473.code AS C_3#5217, 'C_64656661756c745f616972706f727473.gps AS C_11#5218, ('round(('C_64656661756c745f616972706f727473.lat * 'power(10.0, 3)), 0) / 'power(10.0, 3)) AS C_4331#5219, ('round(('C_64656661756c745f616972706f727473.lon * 'power(10.0, 3)), 0) / 'power(10.0, 3)) AS C_4332#5220, ('round(('C_64656661756c745f616972706f727473.elev * 'power(10.0, 3)), 0) / 'power(10.0, 3)) AS C_4333#5221]
               +- 'Filter ((('C_64656661756c745f616972706f727473.lon <= -104.05) AND ('C_64656661756c745f616972706f727473.lon >= -111.05)) AND (('C_64656661756c745f616972706f727473.lat >= 41.0) AND ('C_64656661756c745f616972706f727473.lat <= 45.0)))
                  +- 'SubqueryAlias C_64656661756c745f616972706f727473
                     +- 'UnresolvedRelation [default, airports], [], false

== Analyzed Logical Plan ==
C_13: string, C_18: string, C_23: string, C_16: double, C_21: double, C_22: double, C_20: string, C_15: string, C_25: string, C_12: string, C_24: string, C_14: string, C_19: string, C_17: double
GlobalLimit 5
+- LocalLimit 5
   +- Sort [C_17#5235 DESC NULLS LAST], true
      +- Project [C_10#5206 AS C_13#5222, C_43#5207 AS C_18#5223, C_4#5208 AS C_23#5224, C_4331#5219 AS C_16#5225, C_4332#5220 AS C_21#5226, C_4333#5221 AS C_22#5227, C_7#5212 AS C_20#5228, C_2#5213 AS C_15#5229, C_5#5214 AS C_25#5230, C_8#5215 AS C_12#5231, C_9#5216 AS C_24#5232, C_3#5217 AS C_14#5233, C_11#5218 AS C_19#5234, C_1#5211 AS C_17#5235]
         +- SubqueryAlias C_4954424c
            +- Project [id#5236 AS C_10#5206, type#5237 AS C_43#5207, name#5238 AS C_4#5208, lat#5239 AS C_0#5209, lon#5240 AS C_6#5210, elev#5241 AS C_1#5211, continent#5242 AS C_7#5212, country#5243 AS C_2#5213, region#5244 AS C_5#5214, city#5245 AS C_8#5215, iata#5246 AS C_9#5216, code#5247 AS C_3#5217, gps#5248 AS C_11#5218, (round((lat#5239 * POWER(10.0, cast(3 as double))), 0) / POWER(10.0, cast(3 as double))) AS C_4331#5219, (round((lon#5240 * POWER(10.0, cast(3 as double))), 0) / POWER(10.0, cast(3 as double))) AS C_4332#5220, (round((elev#5241 * POWER(10.0, cast(3 as double))), 0) / POWER(10.0, cast(3 as double))) AS C_4333#5221]
               +- Filter (((lon#5240 <= -104.05) AND (lon#5240 >= -111.05)) AND ((lat#5239 >= 41.0) AND (lat#5239 <= 45.0)))
                  +- SubqueryAlias C_64656661756c745f616972706f727473
                     +- SubqueryAlias spark_catalog.default.airports
                        +- Relation spark_catalog.default.airports[id#5236,type#5237,name#5238,lat#5239,lon#5240,elev#5241,continent#5242,country#5243,region#5244,city#5245,iata#5246,code#5247,gps#5248] parquet

== Optimized Logical Plan ==
GlobalLimit 5
+- LocalLimit 5
   +- Sort [C_17#5235 DESC NULLS LAST], true
      +- Project [id#5236 AS C_13#5222, type#5237 AS C_18#5223, name#5238 AS C_23#5224, (round((lat#5239 * 1000.0), 0) / 1000.0) AS C_16#5225, (round((lon#5240 * 1000.0), 0) / 1000.0) AS C_21#5226, (round((elev#5241 * 1000.0), 0) / 1000.0) AS C_22#5227, continent#5242 AS C_20#5228, country#5243 AS C_15#5229, region#5244 AS C_25#5230, city#5245 AS C_12#5231, iata#5246 AS C_24#5232, code#5247 AS C_14#5233, gps#5248 AS C_19#5234, elev#5241 AS C_17#5235]
         +- Filter ((isnotnull(lon#5240) AND isnotnull(lat#5239)) AND (((lon#5240 <= -104.05) AND (lon#5240 >= -111.05)) AND ((lat#5239 >= 41.0) AND (lat#5239 <= 45.0))))
            +- Relation spark_catalog.default.airports[id#5236,type#5237,name#5238,lat#5239,lon#5240,elev#5241,continent#5242,country#5243,region#5244,city#5245,iata#5246,code#5247,gps#5248] parquet

== Physical Plan ==
TakeOrderedAndProject(limit=5, orderBy=[C_17#5235 DESC NULLS LAST], output=[C_13#5222,C_18#5223,C_23#5224,C_16#5225,C_21#5226,C_22#5227,C_20#5228,C_15#5229,C_25#5230,C_12#5231,C_24#5232,C_14#5233,C_19#5234,C_17#5235])
+- *(1) Project [id#5236 AS C_13#5222, type#5237 AS C_18#5223, name#5238 AS C_23#5224, (round((lat#5239 * 1000.0), 0) / 1000.0) AS C_16#5225, (round((lon#5240 * 1000.0), 0) / 1000.0) AS C_21#5226, (round((elev#5241 * 1000.0), 0) / 1000.0) AS C_22#5227, continent#5242 AS C_20#5228, country#5243 AS C_15#5229, region#5244 AS C_25#5230, city#5245 AS C_12#5231, iata#5246 AS C_24#5232, code#5247 AS C_14#5233, gps#5248 AS C_19#5234, elev#5241 AS C_17#5235]
   +- *(1) Filter (((((isnotnull(lon#5240) AND isnotnull(lat#5239)) AND (lon#5240 <= -104.05)) AND (lon#5240 >= -111.05)) AND (lat#5239 >= 41.0)) AND (lat#5239 <= 45.0))
      +- *(1) ColumnarToRow
         +- FileScan parquet spark_catalog.default.airports[id#5236,type#5237,name#5238,lat#5239,lon#5240,elev#5241,continent#5242,country#5243,region#5244,city#5245,iata#5246,code#5247,gps#5248] Batched: true, DataFilters: [isnotnull(lon#5240), isnotnull(lat#5239), (lon#5240 <= -104.05), (lon#5240 >= -111.05), (lat#523..., Format: Parquet, Location: InMemoryFileIndex(1 paths)[file:/home/acdcadmin/spark-warehouse/airports], PartitionFilters: [], PushedFilters: [IsNotNull(lon), IsNotNull(lat), LessThanOrEqual(lon,-104.05), GreaterThanOrEqual(lon,-111.05), G..., ReadSchema: struct<id:string,type:string,name:string,lat:double,lon:double,elev:double,continent:string,count...

== Parsed Logical Plan ==
'DescribeRelation false, [col_name#5183, data_type#5184, comment#5185]
+- 'UnresolvedTableOrView [default, airports], DESCRIBE TABLE, true

== Analyzed Logical Plan ==
col_name: string, data_type: string, comment: string
DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#5183, data_type#5184, comment#5185]

== Optimized Logical Plan ==
CommandResult [col_name#5183, data_type#5184, comment#5185], Execute DescribeTableCommand, [[id,string,null], [type,string,null], [name,string,null], [lat,double,null], [lon,double,null], [elev,double,null], [continent,string,null], [country,string,null], [region,string,null], [city,string,null], [iata,string,null], [code,string,null], [gps,string,null]]
   +- DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#5183, data_type#5184, comment#5185]

== Physical Plan ==
CommandResult [col_name#5183, data_type#5184, comment#5185]
   +- Execute DescribeTableCommand
         +- DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#5183, data_type#5184, comment#5185]

== Parsed Logical Plan ==
'DescribeRelation false, [col_name#5160, data_type#5161, comment#5162]
+- 'UnresolvedTableOrView [default, airports], DESCRIBE TABLE, true

== Analyzed Logical Plan ==
col_name: string, data_type: string, comment: string
DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#5160, data_type#5161, comment#5162]

== Optimized Logical Plan ==
CommandResult [col_name#5160, data_type#5161, comment#5162], Execute DescribeTableCommand, [[id,string,null], [type,string,null], [name,string,null], [lat,double,null], [lon,double,null], [elev,double,null], [continent,string,null], [country,string,null], [region,string,null], [city,string,null], [iata,string,null], [code,string,null], [gps,string,null]]
   +- DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#5160, data_type#5161, comment#5162]

== Physical Plan ==
CommandResult [col_name#5160, data_type#5161, comment#5162]
   +- Execute DescribeTableCommand
         +- DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#5160, data_type#5161, comment#5162]

== Parsed Logical Plan ==
SetCommand (-v,None)

== Analyzed Logical Plan ==
key: string, value: string, meaning: string, Since version: string
SetCommand (-v,None)

== Optimized Logical Plan ==
CommandResult [key#5135, value#5136, meaning#5137, Since version#5138], Execute SetCommand, [[spark.sql.adaptive.advisoryPartitionSizeInBytes,<value of spark.sql.adaptive.shuffle.targetPostShuffleInputSize>,The advisory size in bytes of the shuffle partition during adaptive optimization (when spark.sql.adaptive.enabled is true). It takes effect when Spark coalesces small shuffle partitions or splits skewed shuffle partition.,3.0.0], [spark.sql.adaptive.autoBroadcastJoinThreshold,<undefined>,Configures the maximum size in bytes for a table that will be broadcast to all worker nodes when performing a join. By setting this value to -1 broadcasting can be disabled. The default value is same with spark.sql.autoBroadcastJoinThreshold. Note that, this config is used only in adaptive framework.,3.2.0], [spark.sql.adaptive.coalescePartitions.enabled,true,When true and 'spark.sql.adaptive.enabled' is true, Spark will coalesce contiguous shuffle partitions according to the target size (specified by 'spark.sql.adaptive.advisoryPartitionSizeInBytes'), to avoid too many small tasks.,3.0.0], [spark.sql.adaptive.coalescePartitions.initialPartitionNum,<undefined>,The initial number of shuffle partitions before coalescing. If not set, it equals to spark.sql.shuffle.partitions. This configuration only has an effect when 'spark.sql.adaptive.enabled' and 'spark.sql.adaptive.coalescePartitions.enabled' are both true.,3.0.0], [spark.sql.adaptive.coalescePartitions.minPartitionSize,1MB,The minimum size of shuffle partitions after coalescing. This is useful when the adaptively calculated target size is too small during partition coalescing.,3.2.0], [spark.sql.adaptive.coalescePartitions.parallelismFirst,true,When true, Spark does not respect the target size specified by 'spark.sql.adaptive.advisoryPartitionSizeInBytes' (default 64MB) when coalescing contiguous shuffle partitions, but adaptively calculate the target size according to the default parallelism of the Spark cluster. The calculated size is usually smaller than the configured target size. This is to maximize the parallelism and avoid performance regression when enabling adaptive query execution. It's recommended to set this config to false and respect the configured target size.,3.2.0], [spark.sql.adaptive.customCostEvaluatorClass,<undefined>,The custom cost evaluator class to be used for adaptive execution. If not being set, Spark will use its own SimpleCostEvaluator by default.,3.2.0], [spark.sql.adaptive.enabled,true,When true, enable adaptive query execution, which re-optimizes the query plan in the middle of query execution, based on accurate runtime statistics.,1.6.0], [spark.sql.adaptive.forceOptimizeSkewedJoin,false,When true, force enable OptimizeSkewedJoin even if it introduces extra shuffle.,3.3.0], [spark.sql.adaptive.localShuffleReader.enabled,true,When true and 'spark.sql.adaptive.enabled' is true, Spark tries to use local shuffle reader to read the shuffle data when the shuffle partitioning is not needed, for example, after converting sort-merge join to broadcast-hash join.,3.0.0], [spark.sql.adaptive.maxShuffledHashJoinLocalMapThreshold,0b,Configures the maximum size in bytes per partition that can be allowed to build local hash map. If this value is not smaller than spark.sql.adaptive.advisoryPartitionSizeInBytes and all the partition size are not larger than this config, join selection prefer to use shuffled hash join instead of sort merge join regardless of the value of spark.sql.join.preferSortMergeJoin.,3.2.0], [spark.sql.adaptive.optimizeSkewsInRebalancePartitions.enabled,true,When true and 'spark.sql.adaptive.enabled' is true, Spark will optimize the skewed shuffle partitions in RebalancePartitions and split them to smaller ones according to the target size (specified by 'spark.sql.adaptive.advisoryPartitionSizeInBytes'), to avoid data skew.,3.2.0], [spark.sql.adaptive.optimizer.excludedRules,<undefined>,Configures a list of rules to be disabled in the adaptive optimizer, in which the rules are specified by their rule names and separated by comma. The optimizer will log the rules that have indeed been excluded.,3.1.0], [spark.sql.adaptive.rebalancePartitionsSmallPartitionFactor,0.2,A partition will be merged during splitting if its size is small than this factor multiply spark.sql.adaptive.advisoryPartitionSizeInBytes.,3.3.0], [spark.sql.adaptive.skewJoin.enabled,true,When true and 'spark.sql.adaptive.enabled' is true, Spark dynamically handles skew in shuffled join (sort-merge and shuffled hash) by splitting (and replicating if needed) skewed partitions.,3.0.0], [spark.sql.adaptive.skewJoin.skewedPartitionFactor,5.0,A partition is considered as skewed if its size is larger than this factor multiplying the median partition size and also larger than 'spark.sql.adaptive.skewJoin.skewedPartitionThresholdInBytes',3.0.0], [spark.sql.adaptive.skewJoin.skewedPartitionThresholdInBytes,256MB,A partition is considered as skewed if its size in bytes is larger than this threshold and also larger than 'spark.sql.adaptive.skewJoin.skewedPartitionFactor' multiplying the median partition size. Ideally this config should be set larger than 'spark.sql.adaptive.advisoryPartitionSizeInBytes'.,3.0.0], [spark.sql.allowNamedFunctionArguments,true,If true, Spark will turn on support for named parameters for all functions that has it implemented.,3.5.0], [spark.sql.ansi.doubleQuotedIdentifiers,false,When true and 'spark.sql.ansi.enabled' is true, Spark SQL reads literals enclosed in double quoted (") as identifiers. When false they are read as string literals.,3.4.0], [spark.sql.ansi.enabled,false,When true, Spark SQL uses an ANSI compliant dialect instead of being Hive compliant. For example, Spark will throw an exception at runtime instead of returning null results when the inputs to a SQL operator/function are invalid.For full details of this dialect, you can find them in the section "ANSI Compliance" of Spark's documentation. Some ANSI dialect features may be not from the ANSI SQL standard directly, but their behaviors align with ANSI SQL's style,3.0.0], [spark.sql.ansi.enforceReservedKeywords,false,When true and 'spark.sql.ansi.enabled' is true, the Spark SQL parser enforces the ANSI reserved keywords and forbids SQL queries that use reserved keywords as alias names and/or identifiers for table, view, function, etc.,3.3.0], [spark.sql.ansi.relationPrecedence,false,When true and 'spark.sql.ansi.enabled' is true, JOIN takes precedence over comma when combining relation. For example, `t1, t2 JOIN t3` should result to `t1 X (t2 X t3)`. If the config is false, the result is `(t1 X t2) X t3`.,3.4.0], [spark.sql.autoBroadcastJoinThreshold,10MB,Configures the maximum size in bytes for a table that will be broadcast to all worker nodes when performing a join.  By setting this value to -1 broadcasting can be disabled. Note that currently statistics are only supported for Hive Metastore tables where the command `ANALYZE TABLE <tableName> COMPUTE STATISTICS noscan` has been run, and file-based data source tables where the statistics are computed directly on the files of data.,1.1.0], [spark.sql.avro.compression.codec,snappy,Compression codec used in writing of AVRO files. Supported codecs: uncompressed, deflate, snappy, bzip2, xz and zstandard. Default codec is snappy.,2.4.0], ... 183 more fields]
   +- SetCommand (-v,None)

== Physical Plan ==
CommandResult [key#5135, value#5136, meaning#5137, Since version#5138]
   +- Execute SetCommand
         +- SetCommand (-v,None)

== Parsed Logical Plan ==
'GlobalLimit 5
+- 'LocalLimit 5
   +- 'Sort ['C_24 DESC NULLS LAST], true
      +- 'Project ['C_43 AS C_21#5078, 'C_0 AS C_12#5079, 'C_1 AS C_17#5080, 'C_4331 AS C_16#5081, 'C_4332 AS C_25#5082, 'C_4333 AS C_23#5083, 'C_4 AS C_19#5084, 'C_5 AS C_20#5085, 'C_7 AS C_14#5086, 'C_8 AS C_18#5087, 'C_9 AS C_22#5088, 'C_11 AS C_15#5089, 'C_10 AS C_13#5090, 'C_3 AS C_24#5091]
         +- 'SubqueryAlias C_4954424c
            +- 'Project ['C_64656661756c745f616972706f727473.id AS C_43#5062, 'C_64656661756c745f616972706f727473.type AS C_0#5063, 'C_64656661756c745f616972706f727473.name AS C_1#5064, 'C_64656661756c745f616972706f727473.lat AS C_2#5065, 'C_64656661756c745f616972706f727473.lon AS C_6#5066, 'C_64656661756c745f616972706f727473.elev AS C_3#5067, 'C_64656661756c745f616972706f727473.continent AS C_4#5068, 'C_64656661756c745f616972706f727473.country AS C_5#5069, 'C_64656661756c745f616972706f727473.region AS C_7#5070, 'C_64656661756c745f616972706f727473.city AS C_8#5071, 'C_64656661756c745f616972706f727473.iata AS C_9#5072, 'C_64656661756c745f616972706f727473.code AS C_11#5073, 'C_64656661756c745f616972706f727473.gps AS C_10#5074, ('round(('C_64656661756c745f616972706f727473.lat * 'power(10.0, 3)), 0) / 'power(10.0, 3)) AS C_4331#5075, ('round(('C_64656661756c745f616972706f727473.lon * 'power(10.0, 3)), 0) / 'power(10.0, 3)) AS C_4332#5076, ('round(('C_64656661756c745f616972706f727473.elev * 'power(10.0, 3)), 0) / 'power(10.0, 3)) AS C_4333#5077]
               +- 'Filter ((('C_64656661756c745f616972706f727473.lon <= -104.05) AND ('C_64656661756c745f616972706f727473.lon >= -111.05)) AND (('C_64656661756c745f616972706f727473.lat >= 41.0) AND ('C_64656661756c745f616972706f727473.lat <= 45.0)))
                  +- 'SubqueryAlias C_64656661756c745f616972706f727473
                     +- 'UnresolvedRelation [default, airports], [], false

== Analyzed Logical Plan ==
C_21: string, C_12: string, C_17: string, C_16: double, C_25: double, C_23: double, C_19: string, C_20: string, C_14: string, C_18: string, C_22: string, C_15: string, C_13: string, C_24: double
GlobalLimit 5
+- LocalLimit 5
   +- Sort [C_24#5091 DESC NULLS LAST], true
      +- Project [C_43#5062 AS C_21#5078, C_0#5063 AS C_12#5079, C_1#5064 AS C_17#5080, C_4331#5075 AS C_16#5081, C_4332#5076 AS C_25#5082, C_4333#5077 AS C_23#5083, C_4#5068 AS C_19#5084, C_5#5069 AS C_20#5085, C_7#5070 AS C_14#5086, C_8#5071 AS C_18#5087, C_9#5072 AS C_22#5088, C_11#5073 AS C_15#5089, C_10#5074 AS C_13#5090, C_3#5067 AS C_24#5091]
         +- SubqueryAlias C_4954424c
            +- Project [id#5092 AS C_43#5062, type#5093 AS C_0#5063, name#5094 AS C_1#5064, lat#5095 AS C_2#5065, lon#5096 AS C_6#5066, elev#5097 AS C_3#5067, continent#5098 AS C_4#5068, country#5099 AS C_5#5069, region#5100 AS C_7#5070, city#5101 AS C_8#5071, iata#5102 AS C_9#5072, code#5103 AS C_11#5073, gps#5104 AS C_10#5074, (round((lat#5095 * POWER(10.0, cast(3 as double))), 0) / POWER(10.0, cast(3 as double))) AS C_4331#5075, (round((lon#5096 * POWER(10.0, cast(3 as double))), 0) / POWER(10.0, cast(3 as double))) AS C_4332#5076, (round((elev#5097 * POWER(10.0, cast(3 as double))), 0) / POWER(10.0, cast(3 as double))) AS C_4333#5077]
               +- Filter (((lon#5096 <= -104.05) AND (lon#5096 >= -111.05)) AND ((lat#5095 >= 41.0) AND (lat#5095 <= 45.0)))
                  +- SubqueryAlias C_64656661756c745f616972706f727473
                     +- SubqueryAlias spark_catalog.default.airports
                        +- Relation spark_catalog.default.airports[id#5092,type#5093,name#5094,lat#5095,lon#5096,elev#5097,continent#5098,country#5099,region#5100,city#5101,iata#5102,code#5103,gps#5104] parquet

== Optimized Logical Plan ==
GlobalLimit 5
+- LocalLimit 5
   +- Sort [C_24#5091 DESC NULLS LAST], true
      +- Project [id#5092 AS C_21#5078, type#5093 AS C_12#5079, name#5094 AS C_17#5080, (round((lat#5095 * 1000.0), 0) / 1000.0) AS C_16#5081, (round((lon#5096 * 1000.0), 0) / 1000.0) AS C_25#5082, (round((elev#5097 * 1000.0), 0) / 1000.0) AS C_23#5083, continent#5098 AS C_19#5084, country#5099 AS C_20#5085, region#5100 AS C_14#5086, city#5101 AS C_18#5087, iata#5102 AS C_22#5088, code#5103 AS C_15#5089, gps#5104 AS C_13#5090, elev#5097 AS C_24#5091]
         +- Filter ((isnotnull(lon#5096) AND isnotnull(lat#5095)) AND (((lon#5096 <= -104.05) AND (lon#5096 >= -111.05)) AND ((lat#5095 >= 41.0) AND (lat#5095 <= 45.0))))
            +- Relation spark_catalog.default.airports[id#5092,type#5093,name#5094,lat#5095,lon#5096,elev#5097,continent#5098,country#5099,region#5100,city#5101,iata#5102,code#5103,gps#5104] parquet

== Physical Plan ==
TakeOrderedAndProject(limit=5, orderBy=[C_24#5091 DESC NULLS LAST], output=[C_21#5078,C_12#5079,C_17#5080,C_16#5081,C_25#5082,C_23#5083,C_19#5084,C_20#5085,C_14#5086,C_18#5087,C_22#5088,C_15#5089,C_13#5090,C_24#5091])
+- *(1) Project [id#5092 AS C_21#5078, type#5093 AS C_12#5079, name#5094 AS C_17#5080, (round((lat#5095 * 1000.0), 0) / 1000.0) AS C_16#5081, (round((lon#5096 * 1000.0), 0) / 1000.0) AS C_25#5082, (round((elev#5097 * 1000.0), 0) / 1000.0) AS C_23#5083, continent#5098 AS C_19#5084, country#5099 AS C_20#5085, region#5100 AS C_14#5086, city#5101 AS C_18#5087, iata#5102 AS C_22#5088, code#5103 AS C_15#5089, gps#5104 AS C_13#5090, elev#5097 AS C_24#5091]
   +- *(1) Filter (((((isnotnull(lon#5096) AND isnotnull(lat#5095)) AND (lon#5096 <= -104.05)) AND (lon#5096 >= -111.05)) AND (lat#5095 >= 41.0)) AND (lat#5095 <= 45.0))
      +- *(1) ColumnarToRow
         +- FileScan parquet spark_catalog.default.airports[id#5092,type#5093,name#5094,lat#5095,lon#5096,elev#5097,continent#5098,country#5099,region#5100,city#5101,iata#5102,code#5103,gps#5104] Batched: true, DataFilters: [isnotnull(lon#5096), isnotnull(lat#5095), (lon#5096 <= -104.05), (lon#5096 >= -111.05), (lat#509..., Format: Parquet, Location: InMemoryFileIndex(1 paths)[file:/home/acdcadmin/spark-warehouse/airports], PartitionFilters: [], PushedFilters: [IsNotNull(lon), IsNotNull(lat), LessThanOrEqual(lon,-104.05), GreaterThanOrEqual(lon,-111.05), G..., ReadSchema: struct<id:string,type:string,name:string,lat:double,lon:double,elev:double,continent:string,count...

== Parsed Logical Plan ==
'DescribeRelation false, [col_name#5039, data_type#5040, comment#5041]
+- 'UnresolvedTableOrView [default, airports], DESCRIBE TABLE, true

== Analyzed Logical Plan ==
col_name: string, data_type: string, comment: string
DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#5039, data_type#5040, comment#5041]

== Optimized Logical Plan ==
CommandResult [col_name#5039, data_type#5040, comment#5041], Execute DescribeTableCommand, [[id,string,null], [type,string,null], [name,string,null], [lat,double,null], [lon,double,null], [elev,double,null], [continent,string,null], [country,string,null], [region,string,null], [city,string,null], [iata,string,null], [code,string,null], [gps,string,null]]
   +- DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#5039, data_type#5040, comment#5041]

== Physical Plan ==
CommandResult [col_name#5039, data_type#5040, comment#5041]
   +- Execute DescribeTableCommand
         +- DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#5039, data_type#5040, comment#5041]

== Parsed Logical Plan ==
'DescribeRelation false, [col_name#5016, data_type#5017, comment#5018]
+- 'UnresolvedTableOrView [default, airports], DESCRIBE TABLE, true

== Analyzed Logical Plan ==
col_name: string, data_type: string, comment: string
DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#5016, data_type#5017, comment#5018]

== Optimized Logical Plan ==
CommandResult [col_name#5016, data_type#5017, comment#5018], Execute DescribeTableCommand, [[id,string,null], [type,string,null], [name,string,null], [lat,double,null], [lon,double,null], [elev,double,null], [continent,string,null], [country,string,null], [region,string,null], [city,string,null], [iata,string,null], [code,string,null], [gps,string,null]]
   +- DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#5016, data_type#5017, comment#5018]

== Physical Plan ==
CommandResult [col_name#5016, data_type#5017, comment#5018]
   +- Execute DescribeTableCommand
         +- DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#5016, data_type#5017, comment#5018]

== Parsed Logical Plan ==
SetCommand (-v,None)

== Analyzed Logical Plan ==
key: string, value: string, meaning: string, Since version: string
SetCommand (-v,None)

== Optimized Logical Plan ==
CommandResult [key#4991, value#4992, meaning#4993, Since version#4994], Execute SetCommand, [[spark.sql.adaptive.advisoryPartitionSizeInBytes,<value of spark.sql.adaptive.shuffle.targetPostShuffleInputSize>,The advisory size in bytes of the shuffle partition during adaptive optimization (when spark.sql.adaptive.enabled is true). It takes effect when Spark coalesces small shuffle partitions or splits skewed shuffle partition.,3.0.0], [spark.sql.adaptive.autoBroadcastJoinThreshold,<undefined>,Configures the maximum size in bytes for a table that will be broadcast to all worker nodes when performing a join. By setting this value to -1 broadcasting can be disabled. The default value is same with spark.sql.autoBroadcastJoinThreshold. Note that, this config is used only in adaptive framework.,3.2.0], [spark.sql.adaptive.coalescePartitions.enabled,true,When true and 'spark.sql.adaptive.enabled' is true, Spark will coalesce contiguous shuffle partitions according to the target size (specified by 'spark.sql.adaptive.advisoryPartitionSizeInBytes'), to avoid too many small tasks.,3.0.0], [spark.sql.adaptive.coalescePartitions.initialPartitionNum,<undefined>,The initial number of shuffle partitions before coalescing. If not set, it equals to spark.sql.shuffle.partitions. This configuration only has an effect when 'spark.sql.adaptive.enabled' and 'spark.sql.adaptive.coalescePartitions.enabled' are both true.,3.0.0], [spark.sql.adaptive.coalescePartitions.minPartitionSize,1MB,The minimum size of shuffle partitions after coalescing. This is useful when the adaptively calculated target size is too small during partition coalescing.,3.2.0], [spark.sql.adaptive.coalescePartitions.parallelismFirst,true,When true, Spark does not respect the target size specified by 'spark.sql.adaptive.advisoryPartitionSizeInBytes' (default 64MB) when coalescing contiguous shuffle partitions, but adaptively calculate the target size according to the default parallelism of the Spark cluster. The calculated size is usually smaller than the configured target size. This is to maximize the parallelism and avoid performance regression when enabling adaptive query execution. It's recommended to set this config to false and respect the configured target size.,3.2.0], [spark.sql.adaptive.customCostEvaluatorClass,<undefined>,The custom cost evaluator class to be used for adaptive execution. If not being set, Spark will use its own SimpleCostEvaluator by default.,3.2.0], [spark.sql.adaptive.enabled,true,When true, enable adaptive query execution, which re-optimizes the query plan in the middle of query execution, based on accurate runtime statistics.,1.6.0], [spark.sql.adaptive.forceOptimizeSkewedJoin,false,When true, force enable OptimizeSkewedJoin even if it introduces extra shuffle.,3.3.0], [spark.sql.adaptive.localShuffleReader.enabled,true,When true and 'spark.sql.adaptive.enabled' is true, Spark tries to use local shuffle reader to read the shuffle data when the shuffle partitioning is not needed, for example, after converting sort-merge join to broadcast-hash join.,3.0.0], [spark.sql.adaptive.maxShuffledHashJoinLocalMapThreshold,0b,Configures the maximum size in bytes per partition that can be allowed to build local hash map. If this value is not smaller than spark.sql.adaptive.advisoryPartitionSizeInBytes and all the partition size are not larger than this config, join selection prefer to use shuffled hash join instead of sort merge join regardless of the value of spark.sql.join.preferSortMergeJoin.,3.2.0], [spark.sql.adaptive.optimizeSkewsInRebalancePartitions.enabled,true,When true and 'spark.sql.adaptive.enabled' is true, Spark will optimize the skewed shuffle partitions in RebalancePartitions and split them to smaller ones according to the target size (specified by 'spark.sql.adaptive.advisoryPartitionSizeInBytes'), to avoid data skew.,3.2.0], [spark.sql.adaptive.optimizer.excludedRules,<undefined>,Configures a list of rules to be disabled in the adaptive optimizer, in which the rules are specified by their rule names and separated by comma. The optimizer will log the rules that have indeed been excluded.,3.1.0], [spark.sql.adaptive.rebalancePartitionsSmallPartitionFactor,0.2,A partition will be merged during splitting if its size is small than this factor multiply spark.sql.adaptive.advisoryPartitionSizeInBytes.,3.3.0], [spark.sql.adaptive.skewJoin.enabled,true,When true and 'spark.sql.adaptive.enabled' is true, Spark dynamically handles skew in shuffled join (sort-merge and shuffled hash) by splitting (and replicating if needed) skewed partitions.,3.0.0], [spark.sql.adaptive.skewJoin.skewedPartitionFactor,5.0,A partition is considered as skewed if its size is larger than this factor multiplying the median partition size and also larger than 'spark.sql.adaptive.skewJoin.skewedPartitionThresholdInBytes',3.0.0], [spark.sql.adaptive.skewJoin.skewedPartitionThresholdInBytes,256MB,A partition is considered as skewed if its size in bytes is larger than this threshold and also larger than 'spark.sql.adaptive.skewJoin.skewedPartitionFactor' multiplying the median partition size. Ideally this config should be set larger than 'spark.sql.adaptive.advisoryPartitionSizeInBytes'.,3.0.0], [spark.sql.allowNamedFunctionArguments,true,If true, Spark will turn on support for named parameters for all functions that has it implemented.,3.5.0], [spark.sql.ansi.doubleQuotedIdentifiers,false,When true and 'spark.sql.ansi.enabled' is true, Spark SQL reads literals enclosed in double quoted (") as identifiers. When false they are read as string literals.,3.4.0], [spark.sql.ansi.enabled,false,When true, Spark SQL uses an ANSI compliant dialect instead of being Hive compliant. For example, Spark will throw an exception at runtime instead of returning null results when the inputs to a SQL operator/function are invalid.For full details of this dialect, you can find them in the section "ANSI Compliance" of Spark's documentation. Some ANSI dialect features may be not from the ANSI SQL standard directly, but their behaviors align with ANSI SQL's style,3.0.0], [spark.sql.ansi.enforceReservedKeywords,false,When true and 'spark.sql.ansi.enabled' is true, the Spark SQL parser enforces the ANSI reserved keywords and forbids SQL queries that use reserved keywords as alias names and/or identifiers for table, view, function, etc.,3.3.0], [spark.sql.ansi.relationPrecedence,false,When true and 'spark.sql.ansi.enabled' is true, JOIN takes precedence over comma when combining relation. For example, `t1, t2 JOIN t3` should result to `t1 X (t2 X t3)`. If the config is false, the result is `(t1 X t2) X t3`.,3.4.0], [spark.sql.autoBroadcastJoinThreshold,10MB,Configures the maximum size in bytes for a table that will be broadcast to all worker nodes when performing a join.  By setting this value to -1 broadcasting can be disabled. Note that currently statistics are only supported for Hive Metastore tables where the command `ANALYZE TABLE <tableName> COMPUTE STATISTICS noscan` has been run, and file-based data source tables where the statistics are computed directly on the files of data.,1.1.0], [spark.sql.avro.compression.codec,snappy,Compression codec used in writing of AVRO files. Supported codecs: uncompressed, deflate, snappy, bzip2, xz and zstandard. Default codec is snappy.,2.4.0], ... 183 more fields]
   +- SetCommand (-v,None)

== Physical Plan ==
CommandResult [key#4991, value#4992, meaning#4993, Since version#4994]
   +- Execute SetCommand
         +- SetCommand (-v,None)

== Parsed Logical Plan ==
'GlobalLimit 5
+- 'LocalLimit 5
   +- 'Sort ['C_25 DESC NULLS LAST], true
      +- 'Project ['C_43 AS C_12#4934, 'C_4 AS C_13#4935, 'C_1 AS C_17#4936, 'C_4331 AS C_19#4937, 'C_4332 AS C_18#4938, 'C_4333 AS C_16#4939, 'C_6 AS C_15#4940, 'C_8 AS C_14#4941, 'C_9 AS C_20#4942, 'C_7 AS C_23#4943, 'C_5 AS C_22#4944, 'C_10 AS C_21#4945, 'C_11 AS C_24#4946, 'C_0 AS C_25#4947]
         +- 'SubqueryAlias C_4954424c
            +- 'Project ['C_64656661756c745f616972706f727473.id AS C_43#4918, 'C_64656661756c745f616972706f727473.type AS C_4#4919, 'C_64656661756c745f616972706f727473.name AS C_1#4920, 'C_64656661756c745f616972706f727473.lat AS C_2#4921, 'C_64656661756c745f616972706f727473.lon AS C_3#4922, 'C_64656661756c745f616972706f727473.elev AS C_0#4923, 'C_64656661756c745f616972706f727473.continent AS C_6#4924, 'C_64656661756c745f616972706f727473.country AS C_8#4925, 'C_64656661756c745f616972706f727473.region AS C_9#4926, 'C_64656661756c745f616972706f727473.city AS C_7#4927, 'C_64656661756c745f616972706f727473.iata AS C_5#4928, 'C_64656661756c745f616972706f727473.code AS C_10#4929, 'C_64656661756c745f616972706f727473.gps AS C_11#4930, ('round(('C_64656661756c745f616972706f727473.lat * 'power(10.0, 3)), 0) / 'power(10.0, 3)) AS C_4331#4931, ('round(('C_64656661756c745f616972706f727473.lon * 'power(10.0, 3)), 0) / 'power(10.0, 3)) AS C_4332#4932, ('round(('C_64656661756c745f616972706f727473.elev * 'power(10.0, 3)), 0) / 'power(10.0, 3)) AS C_4333#4933]
               +- 'Filter ((('C_64656661756c745f616972706f727473.lon <= -104.05) AND ('C_64656661756c745f616972706f727473.lon >= -111.05)) AND (('C_64656661756c745f616972706f727473.lat >= 41.0) AND ('C_64656661756c745f616972706f727473.lat <= 45.0)))
                  +- 'SubqueryAlias C_64656661756c745f616972706f727473
                     +- 'UnresolvedRelation [default, airports], [], false

== Analyzed Logical Plan ==
C_12: string, C_13: string, C_17: string, C_19: double, C_18: double, C_16: double, C_15: string, C_14: string, C_20: string, C_23: string, C_22: string, C_21: string, C_24: string, C_25: double
GlobalLimit 5
+- LocalLimit 5
   +- Sort [C_25#4947 DESC NULLS LAST], true
      +- Project [C_43#4918 AS C_12#4934, C_4#4919 AS C_13#4935, C_1#4920 AS C_17#4936, C_4331#4931 AS C_19#4937, C_4332#4932 AS C_18#4938, C_4333#4933 AS C_16#4939, C_6#4924 AS C_15#4940, C_8#4925 AS C_14#4941, C_9#4926 AS C_20#4942, C_7#4927 AS C_23#4943, C_5#4928 AS C_22#4944, C_10#4929 AS C_21#4945, C_11#4930 AS C_24#4946, C_0#4923 AS C_25#4947]
         +- SubqueryAlias C_4954424c
            +- Project [id#4948 AS C_43#4918, type#4949 AS C_4#4919, name#4950 AS C_1#4920, lat#4951 AS C_2#4921, lon#4952 AS C_3#4922, elev#4953 AS C_0#4923, continent#4954 AS C_6#4924, country#4955 AS C_8#4925, region#4956 AS C_9#4926, city#4957 AS C_7#4927, iata#4958 AS C_5#4928, code#4959 AS C_10#4929, gps#4960 AS C_11#4930, (round((lat#4951 * POWER(10.0, cast(3 as double))), 0) / POWER(10.0, cast(3 as double))) AS C_4331#4931, (round((lon#4952 * POWER(10.0, cast(3 as double))), 0) / POWER(10.0, cast(3 as double))) AS C_4332#4932, (round((elev#4953 * POWER(10.0, cast(3 as double))), 0) / POWER(10.0, cast(3 as double))) AS C_4333#4933]
               +- Filter (((lon#4952 <= -104.05) AND (lon#4952 >= -111.05)) AND ((lat#4951 >= 41.0) AND (lat#4951 <= 45.0)))
                  +- SubqueryAlias C_64656661756c745f616972706f727473
                     +- SubqueryAlias spark_catalog.default.airports
                        +- Relation spark_catalog.default.airports[id#4948,type#4949,name#4950,lat#4951,lon#4952,elev#4953,continent#4954,country#4955,region#4956,city#4957,iata#4958,code#4959,gps#4960] parquet

== Optimized Logical Plan ==
GlobalLimit 5
+- LocalLimit 5
   +- Sort [C_25#4947 DESC NULLS LAST], true
      +- Project [id#4948 AS C_12#4934, type#4949 AS C_13#4935, name#4950 AS C_17#4936, (round((lat#4951 * 1000.0), 0) / 1000.0) AS C_19#4937, (round((lon#4952 * 1000.0), 0) / 1000.0) AS C_18#4938, (round((elev#4953 * 1000.0), 0) / 1000.0) AS C_16#4939, continent#4954 AS C_15#4940, country#4955 AS C_14#4941, region#4956 AS C_20#4942, city#4957 AS C_23#4943, iata#4958 AS C_22#4944, code#4959 AS C_21#4945, gps#4960 AS C_24#4946, elev#4953 AS C_25#4947]
         +- Filter ((isnotnull(lon#4952) AND isnotnull(lat#4951)) AND (((lon#4952 <= -104.05) AND (lon#4952 >= -111.05)) AND ((lat#4951 >= 41.0) AND (lat#4951 <= 45.0))))
            +- Relation spark_catalog.default.airports[id#4948,type#4949,name#4950,lat#4951,lon#4952,elev#4953,continent#4954,country#4955,region#4956,city#4957,iata#4958,code#4959,gps#4960] parquet

== Physical Plan ==
TakeOrderedAndProject(limit=5, orderBy=[C_25#4947 DESC NULLS LAST], output=[C_12#4934,C_13#4935,C_17#4936,C_19#4937,C_18#4938,C_16#4939,C_15#4940,C_14#4941,C_20#4942,C_23#4943,C_22#4944,C_21#4945,C_24#4946,C_25#4947])
+- *(1) Project [id#4948 AS C_12#4934, type#4949 AS C_13#4935, name#4950 AS C_17#4936, (round((lat#4951 * 1000.0), 0) / 1000.0) AS C_19#4937, (round((lon#4952 * 1000.0), 0) / 1000.0) AS C_18#4938, (round((elev#4953 * 1000.0), 0) / 1000.0) AS C_16#4939, continent#4954 AS C_15#4940, country#4955 AS C_14#4941, region#4956 AS C_20#4942, city#4957 AS C_23#4943, iata#4958 AS C_22#4944, code#4959 AS C_21#4945, gps#4960 AS C_24#4946, elev#4953 AS C_25#4947]
   +- *(1) Filter (((((isnotnull(lon#4952) AND isnotnull(lat#4951)) AND (lon#4952 <= -104.05)) AND (lon#4952 >= -111.05)) AND (lat#4951 >= 41.0)) AND (lat#4951 <= 45.0))
      +- *(1) ColumnarToRow
         +- FileScan parquet spark_catalog.default.airports[id#4948,type#4949,name#4950,lat#4951,lon#4952,elev#4953,continent#4954,country#4955,region#4956,city#4957,iata#4958,code#4959,gps#4960] Batched: true, DataFilters: [isnotnull(lon#4952), isnotnull(lat#4951), (lon#4952 <= -104.05), (lon#4952 >= -111.05), (lat#495..., Format: Parquet, Location: InMemoryFileIndex(1 paths)[file:/home/acdcadmin/spark-warehouse/airports], PartitionFilters: [], PushedFilters: [IsNotNull(lon), IsNotNull(lat), LessThanOrEqual(lon,-104.05), GreaterThanOrEqual(lon,-111.05), G..., ReadSchema: struct<id:string,type:string,name:string,lat:double,lon:double,elev:double,continent:string,count...

== Parsed Logical Plan ==
'DescribeRelation false, [col_name#4895, data_type#4896, comment#4897]
+- 'UnresolvedTableOrView [default, airports], DESCRIBE TABLE, true

== Analyzed Logical Plan ==
col_name: string, data_type: string, comment: string
DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#4895, data_type#4896, comment#4897]

== Optimized Logical Plan ==
CommandResult [col_name#4895, data_type#4896, comment#4897], Execute DescribeTableCommand, [[id,string,null], [type,string,null], [name,string,null], [lat,double,null], [lon,double,null], [elev,double,null], [continent,string,null], [country,string,null], [region,string,null], [city,string,null], [iata,string,null], [code,string,null], [gps,string,null]]
   +- DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#4895, data_type#4896, comment#4897]

== Physical Plan ==
CommandResult [col_name#4895, data_type#4896, comment#4897]
   +- Execute DescribeTableCommand
         +- DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#4895, data_type#4896, comment#4897]

== Parsed Logical Plan ==
'DescribeRelation false, [col_name#4872, data_type#4873, comment#4874]
+- 'UnresolvedTableOrView [default, airports], DESCRIBE TABLE, true

== Analyzed Logical Plan ==
col_name: string, data_type: string, comment: string
DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#4872, data_type#4873, comment#4874]

== Optimized Logical Plan ==
CommandResult [col_name#4872, data_type#4873, comment#4874], Execute DescribeTableCommand, [[id,string,null], [type,string,null], [name,string,null], [lat,double,null], [lon,double,null], [elev,double,null], [continent,string,null], [country,string,null], [region,string,null], [city,string,null], [iata,string,null], [code,string,null], [gps,string,null]]
   +- DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#4872, data_type#4873, comment#4874]

== Physical Plan ==
CommandResult [col_name#4872, data_type#4873, comment#4874]
   +- Execute DescribeTableCommand
         +- DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#4872, data_type#4873, comment#4874]

== Parsed Logical Plan ==
SetCommand (-v,None)

== Analyzed Logical Plan ==
key: string, value: string, meaning: string, Since version: string
SetCommand (-v,None)

== Optimized Logical Plan ==
CommandResult [key#4847, value#4848, meaning#4849, Since version#4850], Execute SetCommand, [[spark.sql.adaptive.advisoryPartitionSizeInBytes,<value of spark.sql.adaptive.shuffle.targetPostShuffleInputSize>,The advisory size in bytes of the shuffle partition during adaptive optimization (when spark.sql.adaptive.enabled is true). It takes effect when Spark coalesces small shuffle partitions or splits skewed shuffle partition.,3.0.0], [spark.sql.adaptive.autoBroadcastJoinThreshold,<undefined>,Configures the maximum size in bytes for a table that will be broadcast to all worker nodes when performing a join. By setting this value to -1 broadcasting can be disabled. The default value is same with spark.sql.autoBroadcastJoinThreshold. Note that, this config is used only in adaptive framework.,3.2.0], [spark.sql.adaptive.coalescePartitions.enabled,true,When true and 'spark.sql.adaptive.enabled' is true, Spark will coalesce contiguous shuffle partitions according to the target size (specified by 'spark.sql.adaptive.advisoryPartitionSizeInBytes'), to avoid too many small tasks.,3.0.0], [spark.sql.adaptive.coalescePartitions.initialPartitionNum,<undefined>,The initial number of shuffle partitions before coalescing. If not set, it equals to spark.sql.shuffle.partitions. This configuration only has an effect when 'spark.sql.adaptive.enabled' and 'spark.sql.adaptive.coalescePartitions.enabled' are both true.,3.0.0], [spark.sql.adaptive.coalescePartitions.minPartitionSize,1MB,The minimum size of shuffle partitions after coalescing. This is useful when the adaptively calculated target size is too small during partition coalescing.,3.2.0], [spark.sql.adaptive.coalescePartitions.parallelismFirst,true,When true, Spark does not respect the target size specified by 'spark.sql.adaptive.advisoryPartitionSizeInBytes' (default 64MB) when coalescing contiguous shuffle partitions, but adaptively calculate the target size according to the default parallelism of the Spark cluster. The calculated size is usually smaller than the configured target size. This is to maximize the parallelism and avoid performance regression when enabling adaptive query execution. It's recommended to set this config to false and respect the configured target size.,3.2.0], [spark.sql.adaptive.customCostEvaluatorClass,<undefined>,The custom cost evaluator class to be used for adaptive execution. If not being set, Spark will use its own SimpleCostEvaluator by default.,3.2.0], [spark.sql.adaptive.enabled,true,When true, enable adaptive query execution, which re-optimizes the query plan in the middle of query execution, based on accurate runtime statistics.,1.6.0], [spark.sql.adaptive.forceOptimizeSkewedJoin,false,When true, force enable OptimizeSkewedJoin even if it introduces extra shuffle.,3.3.0], [spark.sql.adaptive.localShuffleReader.enabled,true,When true and 'spark.sql.adaptive.enabled' is true, Spark tries to use local shuffle reader to read the shuffle data when the shuffle partitioning is not needed, for example, after converting sort-merge join to broadcast-hash join.,3.0.0], [spark.sql.adaptive.maxShuffledHashJoinLocalMapThreshold,0b,Configures the maximum size in bytes per partition that can be allowed to build local hash map. If this value is not smaller than spark.sql.adaptive.advisoryPartitionSizeInBytes and all the partition size are not larger than this config, join selection prefer to use shuffled hash join instead of sort merge join regardless of the value of spark.sql.join.preferSortMergeJoin.,3.2.0], [spark.sql.adaptive.optimizeSkewsInRebalancePartitions.enabled,true,When true and 'spark.sql.adaptive.enabled' is true, Spark will optimize the skewed shuffle partitions in RebalancePartitions and split them to smaller ones according to the target size (specified by 'spark.sql.adaptive.advisoryPartitionSizeInBytes'), to avoid data skew.,3.2.0], [spark.sql.adaptive.optimizer.excludedRules,<undefined>,Configures a list of rules to be disabled in the adaptive optimizer, in which the rules are specified by their rule names and separated by comma. The optimizer will log the rules that have indeed been excluded.,3.1.0], [spark.sql.adaptive.rebalancePartitionsSmallPartitionFactor,0.2,A partition will be merged during splitting if its size is small than this factor multiply spark.sql.adaptive.advisoryPartitionSizeInBytes.,3.3.0], [spark.sql.adaptive.skewJoin.enabled,true,When true and 'spark.sql.adaptive.enabled' is true, Spark dynamically handles skew in shuffled join (sort-merge and shuffled hash) by splitting (and replicating if needed) skewed partitions.,3.0.0], [spark.sql.adaptive.skewJoin.skewedPartitionFactor,5.0,A partition is considered as skewed if its size is larger than this factor multiplying the median partition size and also larger than 'spark.sql.adaptive.skewJoin.skewedPartitionThresholdInBytes',3.0.0], [spark.sql.adaptive.skewJoin.skewedPartitionThresholdInBytes,256MB,A partition is considered as skewed if its size in bytes is larger than this threshold and also larger than 'spark.sql.adaptive.skewJoin.skewedPartitionFactor' multiplying the median partition size. Ideally this config should be set larger than 'spark.sql.adaptive.advisoryPartitionSizeInBytes'.,3.0.0], [spark.sql.allowNamedFunctionArguments,true,If true, Spark will turn on support for named parameters for all functions that has it implemented.,3.5.0], [spark.sql.ansi.doubleQuotedIdentifiers,false,When true and 'spark.sql.ansi.enabled' is true, Spark SQL reads literals enclosed in double quoted (") as identifiers. When false they are read as string literals.,3.4.0], [spark.sql.ansi.enabled,false,When true, Spark SQL uses an ANSI compliant dialect instead of being Hive compliant. For example, Spark will throw an exception at runtime instead of returning null results when the inputs to a SQL operator/function are invalid.For full details of this dialect, you can find them in the section "ANSI Compliance" of Spark's documentation. Some ANSI dialect features may be not from the ANSI SQL standard directly, but their behaviors align with ANSI SQL's style,3.0.0], [spark.sql.ansi.enforceReservedKeywords,false,When true and 'spark.sql.ansi.enabled' is true, the Spark SQL parser enforces the ANSI reserved keywords and forbids SQL queries that use reserved keywords as alias names and/or identifiers for table, view, function, etc.,3.3.0], [spark.sql.ansi.relationPrecedence,false,When true and 'spark.sql.ansi.enabled' is true, JOIN takes precedence over comma when combining relation. For example, `t1, t2 JOIN t3` should result to `t1 X (t2 X t3)`. If the config is false, the result is `(t1 X t2) X t3`.,3.4.0], [spark.sql.autoBroadcastJoinThreshold,10MB,Configures the maximum size in bytes for a table that will be broadcast to all worker nodes when performing a join.  By setting this value to -1 broadcasting can be disabled. Note that currently statistics are only supported for Hive Metastore tables where the command `ANALYZE TABLE <tableName> COMPUTE STATISTICS noscan` has been run, and file-based data source tables where the statistics are computed directly on the files of data.,1.1.0], [spark.sql.avro.compression.codec,snappy,Compression codec used in writing of AVRO files. Supported codecs: uncompressed, deflate, snappy, bzip2, xz and zstandard. Default codec is snappy.,2.4.0], ... 183 more fields]
   +- SetCommand (-v,None)

== Physical Plan ==
CommandResult [key#4847, value#4848, meaning#4849, Since version#4850]
   +- Execute SetCommand
         +- SetCommand (-v,None)

== Parsed Logical Plan ==
'GlobalLimit 5
+- 'LocalLimit 5
   +- 'Sort ['C_24 DESC NULLS LAST], true
      +- 'Project ['C_5 AS C_13#4790, 'C_43 AS C_23#4791, 'C_6 AS C_15#4792, 'C_4331 AS C_19#4793, 'C_4332 AS C_21#4794, 'C_4333 AS C_18#4795, 'C_0 AS C_25#4796, 'C_1 AS C_20#4797, 'C_2 AS C_16#4798, 'C_3 AS C_22#4799, 'C_4 AS C_12#4800, 'C_10 AS C_17#4801, 'C_11 AS C_14#4802, 'C_9 AS C_24#4803]
         +- 'SubqueryAlias C_4954424c
            +- 'Project ['C_64656661756c745f616972706f727473.id AS C_5#4774, 'C_64656661756c745f616972706f727473.type AS C_43#4775, 'C_64656661756c745f616972706f727473.name AS C_6#4776, 'C_64656661756c745f616972706f727473.lat AS C_7#4777, 'C_64656661756c745f616972706f727473.lon AS C_8#4778, 'C_64656661756c745f616972706f727473.elev AS C_9#4779, 'C_64656661756c745f616972706f727473.continent AS C_0#4780, 'C_64656661756c745f616972706f727473.country AS C_1#4781, 'C_64656661756c745f616972706f727473.region AS C_2#4782, 'C_64656661756c745f616972706f727473.city AS C_3#4783, 'C_64656661756c745f616972706f727473.iata AS C_4#4784, 'C_64656661756c745f616972706f727473.code AS C_10#4785, 'C_64656661756c745f616972706f727473.gps AS C_11#4786, ('round(('C_64656661756c745f616972706f727473.lat * 'power(10.0, 3)), 0) / 'power(10.0, 3)) AS C_4331#4787, ('round(('C_64656661756c745f616972706f727473.lon * 'power(10.0, 3)), 0) / 'power(10.0, 3)) AS C_4332#4788, ('round(('C_64656661756c745f616972706f727473.elev * 'power(10.0, 3)), 0) / 'power(10.0, 3)) AS C_4333#4789]
               +- 'Filter ((('C_64656661756c745f616972706f727473.lon <= -104.05) AND ('C_64656661756c745f616972706f727473.lon >= -111.05)) AND (('C_64656661756c745f616972706f727473.lat >= 41.0) AND ('C_64656661756c745f616972706f727473.lat <= 45.0)))
                  +- 'SubqueryAlias C_64656661756c745f616972706f727473
                     +- 'UnresolvedRelation [default, airports], [], false

== Analyzed Logical Plan ==
C_13: string, C_23: string, C_15: string, C_19: double, C_21: double, C_18: double, C_25: string, C_20: string, C_16: string, C_22: string, C_12: string, C_17: string, C_14: string, C_24: double
GlobalLimit 5
+- LocalLimit 5
   +- Sort [C_24#4803 DESC NULLS LAST], true
      +- Project [C_5#4774 AS C_13#4790, C_43#4775 AS C_23#4791, C_6#4776 AS C_15#4792, C_4331#4787 AS C_19#4793, C_4332#4788 AS C_21#4794, C_4333#4789 AS C_18#4795, C_0#4780 AS C_25#4796, C_1#4781 AS C_20#4797, C_2#4782 AS C_16#4798, C_3#4783 AS C_22#4799, C_4#4784 AS C_12#4800, C_10#4785 AS C_17#4801, C_11#4786 AS C_14#4802, C_9#4779 AS C_24#4803]
         +- SubqueryAlias C_4954424c
            +- Project [id#4804 AS C_5#4774, type#4805 AS C_43#4775, name#4806 AS C_6#4776, lat#4807 AS C_7#4777, lon#4808 AS C_8#4778, elev#4809 AS C_9#4779, continent#4810 AS C_0#4780, country#4811 AS C_1#4781, region#4812 AS C_2#4782, city#4813 AS C_3#4783, iata#4814 AS C_4#4784, code#4815 AS C_10#4785, gps#4816 AS C_11#4786, (round((lat#4807 * POWER(10.0, cast(3 as double))), 0) / POWER(10.0, cast(3 as double))) AS C_4331#4787, (round((lon#4808 * POWER(10.0, cast(3 as double))), 0) / POWER(10.0, cast(3 as double))) AS C_4332#4788, (round((elev#4809 * POWER(10.0, cast(3 as double))), 0) / POWER(10.0, cast(3 as double))) AS C_4333#4789]
               +- Filter (((lon#4808 <= -104.05) AND (lon#4808 >= -111.05)) AND ((lat#4807 >= 41.0) AND (lat#4807 <= 45.0)))
                  +- SubqueryAlias C_64656661756c745f616972706f727473
                     +- SubqueryAlias spark_catalog.default.airports
                        +- Relation spark_catalog.default.airports[id#4804,type#4805,name#4806,lat#4807,lon#4808,elev#4809,continent#4810,country#4811,region#4812,city#4813,iata#4814,code#4815,gps#4816] parquet

== Optimized Logical Plan ==
GlobalLimit 5
+- LocalLimit 5
   +- Sort [C_24#4803 DESC NULLS LAST], true
      +- Project [id#4804 AS C_13#4790, type#4805 AS C_23#4791, name#4806 AS C_15#4792, (round((lat#4807 * 1000.0), 0) / 1000.0) AS C_19#4793, (round((lon#4808 * 1000.0), 0) / 1000.0) AS C_21#4794, (round((elev#4809 * 1000.0), 0) / 1000.0) AS C_18#4795, continent#4810 AS C_25#4796, country#4811 AS C_20#4797, region#4812 AS C_16#4798, city#4813 AS C_22#4799, iata#4814 AS C_12#4800, code#4815 AS C_17#4801, gps#4816 AS C_14#4802, elev#4809 AS C_24#4803]
         +- Filter ((isnotnull(lon#4808) AND isnotnull(lat#4807)) AND (((lon#4808 <= -104.05) AND (lon#4808 >= -111.05)) AND ((lat#4807 >= 41.0) AND (lat#4807 <= 45.0))))
            +- Relation spark_catalog.default.airports[id#4804,type#4805,name#4806,lat#4807,lon#4808,elev#4809,continent#4810,country#4811,region#4812,city#4813,iata#4814,code#4815,gps#4816] parquet

== Physical Plan ==
TakeOrderedAndProject(limit=5, orderBy=[C_24#4803 DESC NULLS LAST], output=[C_13#4790,C_23#4791,C_15#4792,C_19#4793,C_21#4794,C_18#4795,C_25#4796,C_20#4797,C_16#4798,C_22#4799,C_12#4800,C_17#4801,C_14#4802,C_24#4803])
+- *(1) Project [id#4804 AS C_13#4790, type#4805 AS C_23#4791, name#4806 AS C_15#4792, (round((lat#4807 * 1000.0), 0) / 1000.0) AS C_19#4793, (round((lon#4808 * 1000.0), 0) / 1000.0) AS C_21#4794, (round((elev#4809 * 1000.0), 0) / 1000.0) AS C_18#4795, continent#4810 AS C_25#4796, country#4811 AS C_20#4797, region#4812 AS C_16#4798, city#4813 AS C_22#4799, iata#4814 AS C_12#4800, code#4815 AS C_17#4801, gps#4816 AS C_14#4802, elev#4809 AS C_24#4803]
   +- *(1) Filter (((((isnotnull(lon#4808) AND isnotnull(lat#4807)) AND (lon#4808 <= -104.05)) AND (lon#4808 >= -111.05)) AND (lat#4807 >= 41.0)) AND (lat#4807 <= 45.0))
      +- *(1) ColumnarToRow
         +- FileScan parquet spark_catalog.default.airports[id#4804,type#4805,name#4806,lat#4807,lon#4808,elev#4809,continent#4810,country#4811,region#4812,city#4813,iata#4814,code#4815,gps#4816] Batched: true, DataFilters: [isnotnull(lon#4808), isnotnull(lat#4807), (lon#4808 <= -104.05), (lon#4808 >= -111.05), (lat#480..., Format: Parquet, Location: InMemoryFileIndex(1 paths)[file:/home/acdcadmin/spark-warehouse/airports], PartitionFilters: [], PushedFilters: [IsNotNull(lon), IsNotNull(lat), LessThanOrEqual(lon,-104.05), GreaterThanOrEqual(lon,-111.05), G..., ReadSchema: struct<id:string,type:string,name:string,lat:double,lon:double,elev:double,continent:string,count...

== Parsed Logical Plan ==
'DescribeRelation false, [col_name#4751, data_type#4752, comment#4753]
+- 'UnresolvedTableOrView [default, airports], DESCRIBE TABLE, true

== Analyzed Logical Plan ==
col_name: string, data_type: string, comment: string
DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#4751, data_type#4752, comment#4753]

== Optimized Logical Plan ==
CommandResult [col_name#4751, data_type#4752, comment#4753], Execute DescribeTableCommand, [[id,string,null], [type,string,null], [name,string,null], [lat,double,null], [lon,double,null], [elev,double,null], [continent,string,null], [country,string,null], [region,string,null], [city,string,null], [iata,string,null], [code,string,null], [gps,string,null]]
   +- DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#4751, data_type#4752, comment#4753]

== Physical Plan ==
CommandResult [col_name#4751, data_type#4752, comment#4753]
   +- Execute DescribeTableCommand
         +- DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#4751, data_type#4752, comment#4753]

== Parsed Logical Plan ==
'DescribeRelation false, [col_name#4728, data_type#4729, comment#4730]
+- 'UnresolvedTableOrView [default, airports], DESCRIBE TABLE, true

== Analyzed Logical Plan ==
col_name: string, data_type: string, comment: string
DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#4728, data_type#4729, comment#4730]

== Optimized Logical Plan ==
CommandResult [col_name#4728, data_type#4729, comment#4730], Execute DescribeTableCommand, [[id,string,null], [type,string,null], [name,string,null], [lat,double,null], [lon,double,null], [elev,double,null], [continent,string,null], [country,string,null], [region,string,null], [city,string,null], [iata,string,null], [code,string,null], [gps,string,null]]
   +- DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#4728, data_type#4729, comment#4730]

== Physical Plan ==
CommandResult [col_name#4728, data_type#4729, comment#4730]
   +- Execute DescribeTableCommand
         +- DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#4728, data_type#4729, comment#4730]

== Parsed Logical Plan ==
SetCommand (-v,None)

== Analyzed Logical Plan ==
key: string, value: string, meaning: string, Since version: string
SetCommand (-v,None)

== Optimized Logical Plan ==
CommandResult [key#4703, value#4704, meaning#4705, Since version#4706], Execute SetCommand, [[spark.sql.adaptive.advisoryPartitionSizeInBytes,<value of spark.sql.adaptive.shuffle.targetPostShuffleInputSize>,The advisory size in bytes of the shuffle partition during adaptive optimization (when spark.sql.adaptive.enabled is true). It takes effect when Spark coalesces small shuffle partitions or splits skewed shuffle partition.,3.0.0], [spark.sql.adaptive.autoBroadcastJoinThreshold,<undefined>,Configures the maximum size in bytes for a table that will be broadcast to all worker nodes when performing a join. By setting this value to -1 broadcasting can be disabled. The default value is same with spark.sql.autoBroadcastJoinThreshold. Note that, this config is used only in adaptive framework.,3.2.0], [spark.sql.adaptive.coalescePartitions.enabled,true,When true and 'spark.sql.adaptive.enabled' is true, Spark will coalesce contiguous shuffle partitions according to the target size (specified by 'spark.sql.adaptive.advisoryPartitionSizeInBytes'), to avoid too many small tasks.,3.0.0], [spark.sql.adaptive.coalescePartitions.initialPartitionNum,<undefined>,The initial number of shuffle partitions before coalescing. If not set, it equals to spark.sql.shuffle.partitions. This configuration only has an effect when 'spark.sql.adaptive.enabled' and 'spark.sql.adaptive.coalescePartitions.enabled' are both true.,3.0.0], [spark.sql.adaptive.coalescePartitions.minPartitionSize,1MB,The minimum size of shuffle partitions after coalescing. This is useful when the adaptively calculated target size is too small during partition coalescing.,3.2.0], [spark.sql.adaptive.coalescePartitions.parallelismFirst,true,When true, Spark does not respect the target size specified by 'spark.sql.adaptive.advisoryPartitionSizeInBytes' (default 64MB) when coalescing contiguous shuffle partitions, but adaptively calculate the target size according to the default parallelism of the Spark cluster. The calculated size is usually smaller than the configured target size. This is to maximize the parallelism and avoid performance regression when enabling adaptive query execution. It's recommended to set this config to false and respect the configured target size.,3.2.0], [spark.sql.adaptive.customCostEvaluatorClass,<undefined>,The custom cost evaluator class to be used for adaptive execution. If not being set, Spark will use its own SimpleCostEvaluator by default.,3.2.0], [spark.sql.adaptive.enabled,true,When true, enable adaptive query execution, which re-optimizes the query plan in the middle of query execution, based on accurate runtime statistics.,1.6.0], [spark.sql.adaptive.forceOptimizeSkewedJoin,false,When true, force enable OptimizeSkewedJoin even if it introduces extra shuffle.,3.3.0], [spark.sql.adaptive.localShuffleReader.enabled,true,When true and 'spark.sql.adaptive.enabled' is true, Spark tries to use local shuffle reader to read the shuffle data when the shuffle partitioning is not needed, for example, after converting sort-merge join to broadcast-hash join.,3.0.0], [spark.sql.adaptive.maxShuffledHashJoinLocalMapThreshold,0b,Configures the maximum size in bytes per partition that can be allowed to build local hash map. If this value is not smaller than spark.sql.adaptive.advisoryPartitionSizeInBytes and all the partition size are not larger than this config, join selection prefer to use shuffled hash join instead of sort merge join regardless of the value of spark.sql.join.preferSortMergeJoin.,3.2.0], [spark.sql.adaptive.optimizeSkewsInRebalancePartitions.enabled,true,When true and 'spark.sql.adaptive.enabled' is true, Spark will optimize the skewed shuffle partitions in RebalancePartitions and split them to smaller ones according to the target size (specified by 'spark.sql.adaptive.advisoryPartitionSizeInBytes'), to avoid data skew.,3.2.0], [spark.sql.adaptive.optimizer.excludedRules,<undefined>,Configures a list of rules to be disabled in the adaptive optimizer, in which the rules are specified by their rule names and separated by comma. The optimizer will log the rules that have indeed been excluded.,3.1.0], [spark.sql.adaptive.rebalancePartitionsSmallPartitionFactor,0.2,A partition will be merged during splitting if its size is small than this factor multiply spark.sql.adaptive.advisoryPartitionSizeInBytes.,3.3.0], [spark.sql.adaptive.skewJoin.enabled,true,When true and 'spark.sql.adaptive.enabled' is true, Spark dynamically handles skew in shuffled join (sort-merge and shuffled hash) by splitting (and replicating if needed) skewed partitions.,3.0.0], [spark.sql.adaptive.skewJoin.skewedPartitionFactor,5.0,A partition is considered as skewed if its size is larger than this factor multiplying the median partition size and also larger than 'spark.sql.adaptive.skewJoin.skewedPartitionThresholdInBytes',3.0.0], [spark.sql.adaptive.skewJoin.skewedPartitionThresholdInBytes,256MB,A partition is considered as skewed if its size in bytes is larger than this threshold and also larger than 'spark.sql.adaptive.skewJoin.skewedPartitionFactor' multiplying the median partition size. Ideally this config should be set larger than 'spark.sql.adaptive.advisoryPartitionSizeInBytes'.,3.0.0], [spark.sql.allowNamedFunctionArguments,true,If true, Spark will turn on support for named parameters for all functions that has it implemented.,3.5.0], [spark.sql.ansi.doubleQuotedIdentifiers,false,When true and 'spark.sql.ansi.enabled' is true, Spark SQL reads literals enclosed in double quoted (") as identifiers. When false they are read as string literals.,3.4.0], [spark.sql.ansi.enabled,false,When true, Spark SQL uses an ANSI compliant dialect instead of being Hive compliant. For example, Spark will throw an exception at runtime instead of returning null results when the inputs to a SQL operator/function are invalid.For full details of this dialect, you can find them in the section "ANSI Compliance" of Spark's documentation. Some ANSI dialect features may be not from the ANSI SQL standard directly, but their behaviors align with ANSI SQL's style,3.0.0], [spark.sql.ansi.enforceReservedKeywords,false,When true and 'spark.sql.ansi.enabled' is true, the Spark SQL parser enforces the ANSI reserved keywords and forbids SQL queries that use reserved keywords as alias names and/or identifiers for table, view, function, etc.,3.3.0], [spark.sql.ansi.relationPrecedence,false,When true and 'spark.sql.ansi.enabled' is true, JOIN takes precedence over comma when combining relation. For example, `t1, t2 JOIN t3` should result to `t1 X (t2 X t3)`. If the config is false, the result is `(t1 X t2) X t3`.,3.4.0], [spark.sql.autoBroadcastJoinThreshold,10MB,Configures the maximum size in bytes for a table that will be broadcast to all worker nodes when performing a join.  By setting this value to -1 broadcasting can be disabled. Note that currently statistics are only supported for Hive Metastore tables where the command `ANALYZE TABLE <tableName> COMPUTE STATISTICS noscan` has been run, and file-based data source tables where the statistics are computed directly on the files of data.,1.1.0], [spark.sql.avro.compression.codec,snappy,Compression codec used in writing of AVRO files. Supported codecs: uncompressed, deflate, snappy, bzip2, xz and zstandard. Default codec is snappy.,2.4.0], ... 183 more fields]
   +- SetCommand (-v,None)

== Physical Plan ==
CommandResult [key#4703, value#4704, meaning#4705, Since version#4706]
   +- Execute SetCommand
         +- SetCommand (-v,None)

== Parsed Logical Plan ==
'GlobalLimit 5
+- 'LocalLimit 5
   +- 'Sort ['C_16 DESC NULLS LAST], true
      +- 'Project ['C_5 AS C_18#4646, 'C_6 AS C_19#4647, 'C_0 AS C_15#4648, 'C_4331 AS C_22#4649, 'C_4332 AS C_25#4650, 'C_4333 AS C_20#4651, 'C_4 AS C_23#4652, 'C_43 AS C_14#4653, 'C_11 AS C_12#4654, 'C_8 AS C_17#4655, 'C_7 AS C_24#4656, 'C_9 AS C_21#4657, 'C_10 AS C_13#4658, 'C_3 AS C_16#4659]
         +- 'SubqueryAlias C_4954424c
            +- 'Project ['C_64656661756c745f616972706f727473.id AS C_5#4630, 'C_64656661756c745f616972706f727473.type AS C_6#4631, 'C_64656661756c745f616972706f727473.name AS C_0#4632, 'C_64656661756c745f616972706f727473.lat AS C_1#4633, 'C_64656661756c745f616972706f727473.lon AS C_2#4634, 'C_64656661756c745f616972706f727473.elev AS C_3#4635, 'C_64656661756c745f616972706f727473.continent AS C_4#4636, 'C_64656661756c745f616972706f727473.country AS C_43#4637, 'C_64656661756c745f616972706f727473.region AS C_11#4638, 'C_64656661756c745f616972706f727473.city AS C_8#4639, 'C_64656661756c745f616972706f727473.iata AS C_7#4640, 'C_64656661756c745f616972706f727473.code AS C_9#4641, 'C_64656661756c745f616972706f727473.gps AS C_10#4642, ('round(('C_64656661756c745f616972706f727473.lat * 'power(10.0, 3)), 0) / 'power(10.0, 3)) AS C_4331#4643, ('round(('C_64656661756c745f616972706f727473.lon * 'power(10.0, 3)), 0) / 'power(10.0, 3)) AS C_4332#4644, ('round(('C_64656661756c745f616972706f727473.elev * 'power(10.0, 3)), 0) / 'power(10.0, 3)) AS C_4333#4645]
               +- 'Filter ((('C_64656661756c745f616972706f727473.lon <= -104.05) AND ('C_64656661756c745f616972706f727473.lon >= -111.05)) AND (('C_64656661756c745f616972706f727473.lat >= 41.0) AND ('C_64656661756c745f616972706f727473.lat <= 45.0)))
                  +- 'SubqueryAlias C_64656661756c745f616972706f727473
                     +- 'UnresolvedRelation [default, airports], [], false

== Analyzed Logical Plan ==
C_18: string, C_19: string, C_15: string, C_22: double, C_25: double, C_20: double, C_23: string, C_14: string, C_12: string, C_17: string, C_24: string, C_21: string, C_13: string, C_16: double
GlobalLimit 5
+- LocalLimit 5
   +- Sort [C_16#4659 DESC NULLS LAST], true
      +- Project [C_5#4630 AS C_18#4646, C_6#4631 AS C_19#4647, C_0#4632 AS C_15#4648, C_4331#4643 AS C_22#4649, C_4332#4644 AS C_25#4650, C_4333#4645 AS C_20#4651, C_4#4636 AS C_23#4652, C_43#4637 AS C_14#4653, C_11#4638 AS C_12#4654, C_8#4639 AS C_17#4655, C_7#4640 AS C_24#4656, C_9#4641 AS C_21#4657, C_10#4642 AS C_13#4658, C_3#4635 AS C_16#4659]
         +- SubqueryAlias C_4954424c
            +- Project [id#4660 AS C_5#4630, type#4661 AS C_6#4631, name#4662 AS C_0#4632, lat#4663 AS C_1#4633, lon#4664 AS C_2#4634, elev#4665 AS C_3#4635, continent#4666 AS C_4#4636, country#4667 AS C_43#4637, region#4668 AS C_11#4638, city#4669 AS C_8#4639, iata#4670 AS C_7#4640, code#4671 AS C_9#4641, gps#4672 AS C_10#4642, (round((lat#4663 * POWER(10.0, cast(3 as double))), 0) / POWER(10.0, cast(3 as double))) AS C_4331#4643, (round((lon#4664 * POWER(10.0, cast(3 as double))), 0) / POWER(10.0, cast(3 as double))) AS C_4332#4644, (round((elev#4665 * POWER(10.0, cast(3 as double))), 0) / POWER(10.0, cast(3 as double))) AS C_4333#4645]
               +- Filter (((lon#4664 <= -104.05) AND (lon#4664 >= -111.05)) AND ((lat#4663 >= 41.0) AND (lat#4663 <= 45.0)))
                  +- SubqueryAlias C_64656661756c745f616972706f727473
                     +- SubqueryAlias spark_catalog.default.airports
                        +- Relation spark_catalog.default.airports[id#4660,type#4661,name#4662,lat#4663,lon#4664,elev#4665,continent#4666,country#4667,region#4668,city#4669,iata#4670,code#4671,gps#4672] parquet

== Optimized Logical Plan ==
GlobalLimit 5
+- LocalLimit 5
   +- Sort [C_16#4659 DESC NULLS LAST], true
      +- Project [id#4660 AS C_18#4646, type#4661 AS C_19#4647, name#4662 AS C_15#4648, (round((lat#4663 * 1000.0), 0) / 1000.0) AS C_22#4649, (round((lon#4664 * 1000.0), 0) / 1000.0) AS C_25#4650, (round((elev#4665 * 1000.0), 0) / 1000.0) AS C_20#4651, continent#4666 AS C_23#4652, country#4667 AS C_14#4653, region#4668 AS C_12#4654, city#4669 AS C_17#4655, iata#4670 AS C_24#4656, code#4671 AS C_21#4657, gps#4672 AS C_13#4658, elev#4665 AS C_16#4659]
         +- Filter ((isnotnull(lon#4664) AND isnotnull(lat#4663)) AND (((lon#4664 <= -104.05) AND (lon#4664 >= -111.05)) AND ((lat#4663 >= 41.0) AND (lat#4663 <= 45.0))))
            +- Relation spark_catalog.default.airports[id#4660,type#4661,name#4662,lat#4663,lon#4664,elev#4665,continent#4666,country#4667,region#4668,city#4669,iata#4670,code#4671,gps#4672] parquet

== Physical Plan ==
TakeOrderedAndProject(limit=5, orderBy=[C_16#4659 DESC NULLS LAST], output=[C_18#4646,C_19#4647,C_15#4648,C_22#4649,C_25#4650,C_20#4651,C_23#4652,C_14#4653,C_12#4654,C_17#4655,C_24#4656,C_21#4657,C_13#4658,C_16#4659])
+- *(1) Project [id#4660 AS C_18#4646, type#4661 AS C_19#4647, name#4662 AS C_15#4648, (round((lat#4663 * 1000.0), 0) / 1000.0) AS C_22#4649, (round((lon#4664 * 1000.0), 0) / 1000.0) AS C_25#4650, (round((elev#4665 * 1000.0), 0) / 1000.0) AS C_20#4651, continent#4666 AS C_23#4652, country#4667 AS C_14#4653, region#4668 AS C_12#4654, city#4669 AS C_17#4655, iata#4670 AS C_24#4656, code#4671 AS C_21#4657, gps#4672 AS C_13#4658, elev#4665 AS C_16#4659]
   +- *(1) Filter (((((isnotnull(lon#4664) AND isnotnull(lat#4663)) AND (lon#4664 <= -104.05)) AND (lon#4664 >= -111.05)) AND (lat#4663 >= 41.0)) AND (lat#4663 <= 45.0))
      +- *(1) ColumnarToRow
         +- FileScan parquet spark_catalog.default.airports[id#4660,type#4661,name#4662,lat#4663,lon#4664,elev#4665,continent#4666,country#4667,region#4668,city#4669,iata#4670,code#4671,gps#4672] Batched: true, DataFilters: [isnotnull(lon#4664), isnotnull(lat#4663), (lon#4664 <= -104.05), (lon#4664 >= -111.05), (lat#466..., Format: Parquet, Location: InMemoryFileIndex(1 paths)[file:/home/acdcadmin/spark-warehouse/airports], PartitionFilters: [], PushedFilters: [IsNotNull(lon), IsNotNull(lat), LessThanOrEqual(lon,-104.05), GreaterThanOrEqual(lon,-111.05), G..., ReadSchema: struct<id:string,type:string,name:string,lat:double,lon:double,elev:double,continent:string,count...

== Parsed Logical Plan ==
'DescribeRelation false, [col_name#4607, data_type#4608, comment#4609]
+- 'UnresolvedTableOrView [default, airports], DESCRIBE TABLE, true

== Analyzed Logical Plan ==
col_name: string, data_type: string, comment: string
DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#4607, data_type#4608, comment#4609]

== Optimized Logical Plan ==
CommandResult [col_name#4607, data_type#4608, comment#4609], Execute DescribeTableCommand, [[id,string,null], [type,string,null], [name,string,null], [lat,double,null], [lon,double,null], [elev,double,null], [continent,string,null], [country,string,null], [region,string,null], [city,string,null], [iata,string,null], [code,string,null], [gps,string,null]]
   +- DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#4607, data_type#4608, comment#4609]

== Physical Plan ==
CommandResult [col_name#4607, data_type#4608, comment#4609]
   +- Execute DescribeTableCommand
         +- DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#4607, data_type#4608, comment#4609]

== Parsed Logical Plan ==
'DescribeRelation false, [col_name#4584, data_type#4585, comment#4586]
+- 'UnresolvedTableOrView [default, airports], DESCRIBE TABLE, true

== Analyzed Logical Plan ==
col_name: string, data_type: string, comment: string
DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#4584, data_type#4585, comment#4586]

== Optimized Logical Plan ==
CommandResult [col_name#4584, data_type#4585, comment#4586], Execute DescribeTableCommand, [[id,string,null], [type,string,null], [name,string,null], [lat,double,null], [lon,double,null], [elev,double,null], [continent,string,null], [country,string,null], [region,string,null], [city,string,null], [iata,string,null], [code,string,null], [gps,string,null]]
   +- DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#4584, data_type#4585, comment#4586]

== Physical Plan ==
CommandResult [col_name#4584, data_type#4585, comment#4586]
   +- Execute DescribeTableCommand
         +- DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#4584, data_type#4585, comment#4586]

== Parsed Logical Plan ==
SetCommand (-v,None)

== Analyzed Logical Plan ==
key: string, value: string, meaning: string, Since version: string
SetCommand (-v,None)

== Optimized Logical Plan ==
CommandResult [key#4559, value#4560, meaning#4561, Since version#4562], Execute SetCommand, [[spark.sql.adaptive.advisoryPartitionSizeInBytes,<value of spark.sql.adaptive.shuffle.targetPostShuffleInputSize>,The advisory size in bytes of the shuffle partition during adaptive optimization (when spark.sql.adaptive.enabled is true). It takes effect when Spark coalesces small shuffle partitions or splits skewed shuffle partition.,3.0.0], [spark.sql.adaptive.autoBroadcastJoinThreshold,<undefined>,Configures the maximum size in bytes for a table that will be broadcast to all worker nodes when performing a join. By setting this value to -1 broadcasting can be disabled. The default value is same with spark.sql.autoBroadcastJoinThreshold. Note that, this config is used only in adaptive framework.,3.2.0], [spark.sql.adaptive.coalescePartitions.enabled,true,When true and 'spark.sql.adaptive.enabled' is true, Spark will coalesce contiguous shuffle partitions according to the target size (specified by 'spark.sql.adaptive.advisoryPartitionSizeInBytes'), to avoid too many small tasks.,3.0.0], [spark.sql.adaptive.coalescePartitions.initialPartitionNum,<undefined>,The initial number of shuffle partitions before coalescing. If not set, it equals to spark.sql.shuffle.partitions. This configuration only has an effect when 'spark.sql.adaptive.enabled' and 'spark.sql.adaptive.coalescePartitions.enabled' are both true.,3.0.0], [spark.sql.adaptive.coalescePartitions.minPartitionSize,1MB,The minimum size of shuffle partitions after coalescing. This is useful when the adaptively calculated target size is too small during partition coalescing.,3.2.0], [spark.sql.adaptive.coalescePartitions.parallelismFirst,true,When true, Spark does not respect the target size specified by 'spark.sql.adaptive.advisoryPartitionSizeInBytes' (default 64MB) when coalescing contiguous shuffle partitions, but adaptively calculate the target size according to the default parallelism of the Spark cluster. The calculated size is usually smaller than the configured target size. This is to maximize the parallelism and avoid performance regression when enabling adaptive query execution. It's recommended to set this config to false and respect the configured target size.,3.2.0], [spark.sql.adaptive.customCostEvaluatorClass,<undefined>,The custom cost evaluator class to be used for adaptive execution. If not being set, Spark will use its own SimpleCostEvaluator by default.,3.2.0], [spark.sql.adaptive.enabled,true,When true, enable adaptive query execution, which re-optimizes the query plan in the middle of query execution, based on accurate runtime statistics.,1.6.0], [spark.sql.adaptive.forceOptimizeSkewedJoin,false,When true, force enable OptimizeSkewedJoin even if it introduces extra shuffle.,3.3.0], [spark.sql.adaptive.localShuffleReader.enabled,true,When true and 'spark.sql.adaptive.enabled' is true, Spark tries to use local shuffle reader to read the shuffle data when the shuffle partitioning is not needed, for example, after converting sort-merge join to broadcast-hash join.,3.0.0], [spark.sql.adaptive.maxShuffledHashJoinLocalMapThreshold,0b,Configures the maximum size in bytes per partition that can be allowed to build local hash map. If this value is not smaller than spark.sql.adaptive.advisoryPartitionSizeInBytes and all the partition size are not larger than this config, join selection prefer to use shuffled hash join instead of sort merge join regardless of the value of spark.sql.join.preferSortMergeJoin.,3.2.0], [spark.sql.adaptive.optimizeSkewsInRebalancePartitions.enabled,true,When true and 'spark.sql.adaptive.enabled' is true, Spark will optimize the skewed shuffle partitions in RebalancePartitions and split them to smaller ones according to the target size (specified by 'spark.sql.adaptive.advisoryPartitionSizeInBytes'), to avoid data skew.,3.2.0], [spark.sql.adaptive.optimizer.excludedRules,<undefined>,Configures a list of rules to be disabled in the adaptive optimizer, in which the rules are specified by their rule names and separated by comma. The optimizer will log the rules that have indeed been excluded.,3.1.0], [spark.sql.adaptive.rebalancePartitionsSmallPartitionFactor,0.2,A partition will be merged during splitting if its size is small than this factor multiply spark.sql.adaptive.advisoryPartitionSizeInBytes.,3.3.0], [spark.sql.adaptive.skewJoin.enabled,true,When true and 'spark.sql.adaptive.enabled' is true, Spark dynamically handles skew in shuffled join (sort-merge and shuffled hash) by splitting (and replicating if needed) skewed partitions.,3.0.0], [spark.sql.adaptive.skewJoin.skewedPartitionFactor,5.0,A partition is considered as skewed if its size is larger than this factor multiplying the median partition size and also larger than 'spark.sql.adaptive.skewJoin.skewedPartitionThresholdInBytes',3.0.0], [spark.sql.adaptive.skewJoin.skewedPartitionThresholdInBytes,256MB,A partition is considered as skewed if its size in bytes is larger than this threshold and also larger than 'spark.sql.adaptive.skewJoin.skewedPartitionFactor' multiplying the median partition size. Ideally this config should be set larger than 'spark.sql.adaptive.advisoryPartitionSizeInBytes'.,3.0.0], [spark.sql.allowNamedFunctionArguments,true,If true, Spark will turn on support for named parameters for all functions that has it implemented.,3.5.0], [spark.sql.ansi.doubleQuotedIdentifiers,false,When true and 'spark.sql.ansi.enabled' is true, Spark SQL reads literals enclosed in double quoted (") as identifiers. When false they are read as string literals.,3.4.0], [spark.sql.ansi.enabled,false,When true, Spark SQL uses an ANSI compliant dialect instead of being Hive compliant. For example, Spark will throw an exception at runtime instead of returning null results when the inputs to a SQL operator/function are invalid.For full details of this dialect, you can find them in the section "ANSI Compliance" of Spark's documentation. Some ANSI dialect features may be not from the ANSI SQL standard directly, but their behaviors align with ANSI SQL's style,3.0.0], [spark.sql.ansi.enforceReservedKeywords,false,When true and 'spark.sql.ansi.enabled' is true, the Spark SQL parser enforces the ANSI reserved keywords and forbids SQL queries that use reserved keywords as alias names and/or identifiers for table, view, function, etc.,3.3.0], [spark.sql.ansi.relationPrecedence,false,When true and 'spark.sql.ansi.enabled' is true, JOIN takes precedence over comma when combining relation. For example, `t1, t2 JOIN t3` should result to `t1 X (t2 X t3)`. If the config is false, the result is `(t1 X t2) X t3`.,3.4.0], [spark.sql.autoBroadcastJoinThreshold,10MB,Configures the maximum size in bytes for a table that will be broadcast to all worker nodes when performing a join.  By setting this value to -1 broadcasting can be disabled. Note that currently statistics are only supported for Hive Metastore tables where the command `ANALYZE TABLE <tableName> COMPUTE STATISTICS noscan` has been run, and file-based data source tables where the statistics are computed directly on the files of data.,1.1.0], [spark.sql.avro.compression.codec,snappy,Compression codec used in writing of AVRO files. Supported codecs: uncompressed, deflate, snappy, bzip2, xz and zstandard. Default codec is snappy.,2.4.0], ... 183 more fields]
   +- SetCommand (-v,None)

== Physical Plan ==
CommandResult [key#4559, value#4560, meaning#4561, Since version#4562]
   +- Execute SetCommand
         +- SetCommand (-v,None)

== Parsed Logical Plan ==
'GlobalLimit 5
+- 'LocalLimit 5
   +- 'Sort ['C_24 DESC NULLS LAST], true
      +- 'Project ['C_0 AS C_14#4502, 'C_1 AS C_13#4503, 'C_43 AS C_12#4504, 'C_4331 AS C_18#4505, 'C_4332 AS C_20#4506, 'C_4333 AS C_16#4507, 'C_6 AS C_19#4508, 'C_8 AS C_17#4509, 'C_5 AS C_15#4510, 'C_7 AS C_22#4511, 'C_9 AS C_25#4512, 'C_11 AS C_23#4513, 'C_10 AS C_21#4514, 'C_3 AS C_24#4515]
         +- 'SubqueryAlias C_4954424c
            +- 'Project ['C_64656661756c745f616972706f727473.id AS C_0#4486, 'C_64656661756c745f616972706f727473.type AS C_1#4487, 'C_64656661756c745f616972706f727473.name AS C_43#4488, 'C_64656661756c745f616972706f727473.lat AS C_2#4489, 'C_64656661756c745f616972706f727473.lon AS C_4#4490, 'C_64656661756c745f616972706f727473.elev AS C_3#4491, 'C_64656661756c745f616972706f727473.continent AS C_6#4492, 'C_64656661756c745f616972706f727473.country AS C_8#4493, 'C_64656661756c745f616972706f727473.region AS C_5#4494, 'C_64656661756c745f616972706f727473.city AS C_7#4495, 'C_64656661756c745f616972706f727473.iata AS C_9#4496, 'C_64656661756c745f616972706f727473.code AS C_11#4497, 'C_64656661756c745f616972706f727473.gps AS C_10#4498, ('round(('C_64656661756c745f616972706f727473.lat * 'power(10.0, 3)), 0) / 'power(10.0, 3)) AS C_4331#4499, ('round(('C_64656661756c745f616972706f727473.lon * 'power(10.0, 3)), 0) / 'power(10.0, 3)) AS C_4332#4500, ('round(('C_64656661756c745f616972706f727473.elev * 'power(10.0, 3)), 0) / 'power(10.0, 3)) AS C_4333#4501]
               +- 'Filter ((('C_64656661756c745f616972706f727473.lon <= -104.05) AND ('C_64656661756c745f616972706f727473.lon >= -111.05)) AND (('C_64656661756c745f616972706f727473.lat >= 41.0) AND ('C_64656661756c745f616972706f727473.lat <= 45.0)))
                  +- 'SubqueryAlias C_64656661756c745f616972706f727473
                     +- 'UnresolvedRelation [default, airports], [], false

== Analyzed Logical Plan ==
C_14: string, C_13: string, C_12: string, C_18: double, C_20: double, C_16: double, C_19: string, C_17: string, C_15: string, C_22: string, C_25: string, C_23: string, C_21: string, C_24: double
GlobalLimit 5
+- LocalLimit 5
   +- Sort [C_24#4515 DESC NULLS LAST], true
      +- Project [C_0#4486 AS C_14#4502, C_1#4487 AS C_13#4503, C_43#4488 AS C_12#4504, C_4331#4499 AS C_18#4505, C_4332#4500 AS C_20#4506, C_4333#4501 AS C_16#4507, C_6#4492 AS C_19#4508, C_8#4493 AS C_17#4509, C_5#4494 AS C_15#4510, C_7#4495 AS C_22#4511, C_9#4496 AS C_25#4512, C_11#4497 AS C_23#4513, C_10#4498 AS C_21#4514, C_3#4491 AS C_24#4515]
         +- SubqueryAlias C_4954424c
            +- Project [id#4516 AS C_0#4486, type#4517 AS C_1#4487, name#4518 AS C_43#4488, lat#4519 AS C_2#4489, lon#4520 AS C_4#4490, elev#4521 AS C_3#4491, continent#4522 AS C_6#4492, country#4523 AS C_8#4493, region#4524 AS C_5#4494, city#4525 AS C_7#4495, iata#4526 AS C_9#4496, code#4527 AS C_11#4497, gps#4528 AS C_10#4498, (round((lat#4519 * POWER(10.0, cast(3 as double))), 0) / POWER(10.0, cast(3 as double))) AS C_4331#4499, (round((lon#4520 * POWER(10.0, cast(3 as double))), 0) / POWER(10.0, cast(3 as double))) AS C_4332#4500, (round((elev#4521 * POWER(10.0, cast(3 as double))), 0) / POWER(10.0, cast(3 as double))) AS C_4333#4501]
               +- Filter (((lon#4520 <= -104.05) AND (lon#4520 >= -111.05)) AND ((lat#4519 >= 41.0) AND (lat#4519 <= 45.0)))
                  +- SubqueryAlias C_64656661756c745f616972706f727473
                     +- SubqueryAlias spark_catalog.default.airports
                        +- Relation spark_catalog.default.airports[id#4516,type#4517,name#4518,lat#4519,lon#4520,elev#4521,continent#4522,country#4523,region#4524,city#4525,iata#4526,code#4527,gps#4528] parquet

== Optimized Logical Plan ==
GlobalLimit 5
+- LocalLimit 5
   +- Sort [C_24#4515 DESC NULLS LAST], true
      +- Project [id#4516 AS C_14#4502, type#4517 AS C_13#4503, name#4518 AS C_12#4504, (round((lat#4519 * 1000.0), 0) / 1000.0) AS C_18#4505, (round((lon#4520 * 1000.0), 0) / 1000.0) AS C_20#4506, (round((elev#4521 * 1000.0), 0) / 1000.0) AS C_16#4507, continent#4522 AS C_19#4508, country#4523 AS C_17#4509, region#4524 AS C_15#4510, city#4525 AS C_22#4511, iata#4526 AS C_25#4512, code#4527 AS C_23#4513, gps#4528 AS C_21#4514, elev#4521 AS C_24#4515]
         +- Filter ((isnotnull(lon#4520) AND isnotnull(lat#4519)) AND (((lon#4520 <= -104.05) AND (lon#4520 >= -111.05)) AND ((lat#4519 >= 41.0) AND (lat#4519 <= 45.0))))
            +- Relation spark_catalog.default.airports[id#4516,type#4517,name#4518,lat#4519,lon#4520,elev#4521,continent#4522,country#4523,region#4524,city#4525,iata#4526,code#4527,gps#4528] parquet

== Physical Plan ==
TakeOrderedAndProject(limit=5, orderBy=[C_24#4515 DESC NULLS LAST], output=[C_14#4502,C_13#4503,C_12#4504,C_18#4505,C_20#4506,C_16#4507,C_19#4508,C_17#4509,C_15#4510,C_22#4511,C_25#4512,C_23#4513,C_21#4514,C_24#4515])
+- *(1) Project [id#4516 AS C_14#4502, type#4517 AS C_13#4503, name#4518 AS C_12#4504, (round((lat#4519 * 1000.0), 0) / 1000.0) AS C_18#4505, (round((lon#4520 * 1000.0), 0) / 1000.0) AS C_20#4506, (round((elev#4521 * 1000.0), 0) / 1000.0) AS C_16#4507, continent#4522 AS C_19#4508, country#4523 AS C_17#4509, region#4524 AS C_15#4510, city#4525 AS C_22#4511, iata#4526 AS C_25#4512, code#4527 AS C_23#4513, gps#4528 AS C_21#4514, elev#4521 AS C_24#4515]
   +- *(1) Filter (((((isnotnull(lon#4520) AND isnotnull(lat#4519)) AND (lon#4520 <= -104.05)) AND (lon#4520 >= -111.05)) AND (lat#4519 >= 41.0)) AND (lat#4519 <= 45.0))
      +- *(1) ColumnarToRow
         +- FileScan parquet spark_catalog.default.airports[id#4516,type#4517,name#4518,lat#4519,lon#4520,elev#4521,continent#4522,country#4523,region#4524,city#4525,iata#4526,code#4527,gps#4528] Batched: true, DataFilters: [isnotnull(lon#4520), isnotnull(lat#4519), (lon#4520 <= -104.05), (lon#4520 >= -111.05), (lat#451..., Format: Parquet, Location: InMemoryFileIndex(1 paths)[file:/home/acdcadmin/spark-warehouse/airports], PartitionFilters: [], PushedFilters: [IsNotNull(lon), IsNotNull(lat), LessThanOrEqual(lon,-104.05), GreaterThanOrEqual(lon,-111.05), G..., ReadSchema: struct<id:string,type:string,name:string,lat:double,lon:double,elev:double,continent:string,count...

== Parsed Logical Plan ==
'DescribeRelation false, [col_name#4463, data_type#4464, comment#4465]
+- 'UnresolvedTableOrView [default, airports], DESCRIBE TABLE, true

== Analyzed Logical Plan ==
col_name: string, data_type: string, comment: string
DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#4463, data_type#4464, comment#4465]

== Optimized Logical Plan ==
CommandResult [col_name#4463, data_type#4464, comment#4465], Execute DescribeTableCommand, [[id,string,null], [type,string,null], [name,string,null], [lat,double,null], [lon,double,null], [elev,double,null], [continent,string,null], [country,string,null], [region,string,null], [city,string,null], [iata,string,null], [code,string,null], [gps,string,null]]
   +- DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#4463, data_type#4464, comment#4465]

== Physical Plan ==
CommandResult [col_name#4463, data_type#4464, comment#4465]
   +- Execute DescribeTableCommand
         +- DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#4463, data_type#4464, comment#4465]

== Parsed Logical Plan ==
'DescribeRelation false, [col_name#4440, data_type#4441, comment#4442]
+- 'UnresolvedTableOrView [default, airports], DESCRIBE TABLE, true

== Analyzed Logical Plan ==
col_name: string, data_type: string, comment: string
DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#4440, data_type#4441, comment#4442]

== Optimized Logical Plan ==
CommandResult [col_name#4440, data_type#4441, comment#4442], Execute DescribeTableCommand, [[id,string,null], [type,string,null], [name,string,null], [lat,double,null], [lon,double,null], [elev,double,null], [continent,string,null], [country,string,null], [region,string,null], [city,string,null], [iata,string,null], [code,string,null], [gps,string,null]]
   +- DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#4440, data_type#4441, comment#4442]

== Physical Plan ==
CommandResult [col_name#4440, data_type#4441, comment#4442]
   +- Execute DescribeTableCommand
         +- DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#4440, data_type#4441, comment#4442]

== Parsed Logical Plan ==
SetCommand (-v,None)

== Analyzed Logical Plan ==
key: string, value: string, meaning: string, Since version: string
SetCommand (-v,None)

== Optimized Logical Plan ==
CommandResult [key#4415, value#4416, meaning#4417, Since version#4418], Execute SetCommand, [[spark.sql.adaptive.advisoryPartitionSizeInBytes,<value of spark.sql.adaptive.shuffle.targetPostShuffleInputSize>,The advisory size in bytes of the shuffle partition during adaptive optimization (when spark.sql.adaptive.enabled is true). It takes effect when Spark coalesces small shuffle partitions or splits skewed shuffle partition.,3.0.0], [spark.sql.adaptive.autoBroadcastJoinThreshold,<undefined>,Configures the maximum size in bytes for a table that will be broadcast to all worker nodes when performing a join. By setting this value to -1 broadcasting can be disabled. The default value is same with spark.sql.autoBroadcastJoinThreshold. Note that, this config is used only in adaptive framework.,3.2.0], [spark.sql.adaptive.coalescePartitions.enabled,true,When true and 'spark.sql.adaptive.enabled' is true, Spark will coalesce contiguous shuffle partitions according to the target size (specified by 'spark.sql.adaptive.advisoryPartitionSizeInBytes'), to avoid too many small tasks.,3.0.0], [spark.sql.adaptive.coalescePartitions.initialPartitionNum,<undefined>,The initial number of shuffle partitions before coalescing. If not set, it equals to spark.sql.shuffle.partitions. This configuration only has an effect when 'spark.sql.adaptive.enabled' and 'spark.sql.adaptive.coalescePartitions.enabled' are both true.,3.0.0], [spark.sql.adaptive.coalescePartitions.minPartitionSize,1MB,The minimum size of shuffle partitions after coalescing. This is useful when the adaptively calculated target size is too small during partition coalescing.,3.2.0], [spark.sql.adaptive.coalescePartitions.parallelismFirst,true,When true, Spark does not respect the target size specified by 'spark.sql.adaptive.advisoryPartitionSizeInBytes' (default 64MB) when coalescing contiguous shuffle partitions, but adaptively calculate the target size according to the default parallelism of the Spark cluster. The calculated size is usually smaller than the configured target size. This is to maximize the parallelism and avoid performance regression when enabling adaptive query execution. It's recommended to set this config to false and respect the configured target size.,3.2.0], [spark.sql.adaptive.customCostEvaluatorClass,<undefined>,The custom cost evaluator class to be used for adaptive execution. If not being set, Spark will use its own SimpleCostEvaluator by default.,3.2.0], [spark.sql.adaptive.enabled,true,When true, enable adaptive query execution, which re-optimizes the query plan in the middle of query execution, based on accurate runtime statistics.,1.6.0], [spark.sql.adaptive.forceOptimizeSkewedJoin,false,When true, force enable OptimizeSkewedJoin even if it introduces extra shuffle.,3.3.0], [spark.sql.adaptive.localShuffleReader.enabled,true,When true and 'spark.sql.adaptive.enabled' is true, Spark tries to use local shuffle reader to read the shuffle data when the shuffle partitioning is not needed, for example, after converting sort-merge join to broadcast-hash join.,3.0.0], [spark.sql.adaptive.maxShuffledHashJoinLocalMapThreshold,0b,Configures the maximum size in bytes per partition that can be allowed to build local hash map. If this value is not smaller than spark.sql.adaptive.advisoryPartitionSizeInBytes and all the partition size are not larger than this config, join selection prefer to use shuffled hash join instead of sort merge join regardless of the value of spark.sql.join.preferSortMergeJoin.,3.2.0], [spark.sql.adaptive.optimizeSkewsInRebalancePartitions.enabled,true,When true and 'spark.sql.adaptive.enabled' is true, Spark will optimize the skewed shuffle partitions in RebalancePartitions and split them to smaller ones according to the target size (specified by 'spark.sql.adaptive.advisoryPartitionSizeInBytes'), to avoid data skew.,3.2.0], [spark.sql.adaptive.optimizer.excludedRules,<undefined>,Configures a list of rules to be disabled in the adaptive optimizer, in which the rules are specified by their rule names and separated by comma. The optimizer will log the rules that have indeed been excluded.,3.1.0], [spark.sql.adaptive.rebalancePartitionsSmallPartitionFactor,0.2,A partition will be merged during splitting if its size is small than this factor multiply spark.sql.adaptive.advisoryPartitionSizeInBytes.,3.3.0], [spark.sql.adaptive.skewJoin.enabled,true,When true and 'spark.sql.adaptive.enabled' is true, Spark dynamically handles skew in shuffled join (sort-merge and shuffled hash) by splitting (and replicating if needed) skewed partitions.,3.0.0], [spark.sql.adaptive.skewJoin.skewedPartitionFactor,5.0,A partition is considered as skewed if its size is larger than this factor multiplying the median partition size and also larger than 'spark.sql.adaptive.skewJoin.skewedPartitionThresholdInBytes',3.0.0], [spark.sql.adaptive.skewJoin.skewedPartitionThresholdInBytes,256MB,A partition is considered as skewed if its size in bytes is larger than this threshold and also larger than 'spark.sql.adaptive.skewJoin.skewedPartitionFactor' multiplying the median partition size. Ideally this config should be set larger than 'spark.sql.adaptive.advisoryPartitionSizeInBytes'.,3.0.0], [spark.sql.allowNamedFunctionArguments,true,If true, Spark will turn on support for named parameters for all functions that has it implemented.,3.5.0], [spark.sql.ansi.doubleQuotedIdentifiers,false,When true and 'spark.sql.ansi.enabled' is true, Spark SQL reads literals enclosed in double quoted (") as identifiers. When false they are read as string literals.,3.4.0], [spark.sql.ansi.enabled,false,When true, Spark SQL uses an ANSI compliant dialect instead of being Hive compliant. For example, Spark will throw an exception at runtime instead of returning null results when the inputs to a SQL operator/function are invalid.For full details of this dialect, you can find them in the section "ANSI Compliance" of Spark's documentation. Some ANSI dialect features may be not from the ANSI SQL standard directly, but their behaviors align with ANSI SQL's style,3.0.0], [spark.sql.ansi.enforceReservedKeywords,false,When true and 'spark.sql.ansi.enabled' is true, the Spark SQL parser enforces the ANSI reserved keywords and forbids SQL queries that use reserved keywords as alias names and/or identifiers for table, view, function, etc.,3.3.0], [spark.sql.ansi.relationPrecedence,false,When true and 'spark.sql.ansi.enabled' is true, JOIN takes precedence over comma when combining relation. For example, `t1, t2 JOIN t3` should result to `t1 X (t2 X t3)`. If the config is false, the result is `(t1 X t2) X t3`.,3.4.0], [spark.sql.autoBroadcastJoinThreshold,10MB,Configures the maximum size in bytes for a table that will be broadcast to all worker nodes when performing a join.  By setting this value to -1 broadcasting can be disabled. Note that currently statistics are only supported for Hive Metastore tables where the command `ANALYZE TABLE <tableName> COMPUTE STATISTICS noscan` has been run, and file-based data source tables where the statistics are computed directly on the files of data.,1.1.0], [spark.sql.avro.compression.codec,snappy,Compression codec used in writing of AVRO files. Supported codecs: uncompressed, deflate, snappy, bzip2, xz and zstandard. Default codec is snappy.,2.4.0], ... 183 more fields]
   +- SetCommand (-v,None)

== Physical Plan ==
CommandResult [key#4415, value#4416, meaning#4417, Since version#4418]
   +- Execute SetCommand
         +- SetCommand (-v,None)

== Parsed Logical Plan ==
'DescribeRelation false, [col_name#4388, data_type#4389, comment#4390]
+- 'UnresolvedTableOrView [default, alltypes], DESCRIBE TABLE, true

== Analyzed Logical Plan ==
col_name: string, data_type: string, comment: string
DescribeTableCommand `spark_catalog`.`default`.`alltypes`, false, [col_name#4388, data_type#4389, comment#4390]

== Optimized Logical Plan ==
CommandResult [col_name#4388, data_type#4389, comment#4390], Execute DescribeTableCommand, [[STRING,string,null], [DOUBLE,double,null], [INTEGER,int,null], [BIGINT,bigint,null], [FLOAT,float,null], [DECIMAL,decimal(10,2),null], [NUMBER,decimal(10,2),null], [BOOLEAN,boolean,null], [DATE,date,null], [TIMESTAMP,timestamp,null], [DATETIME,timestamp,null], [BINARY,binary,null], [ARRAY,array<int>,null], [MAP,map<string,string>,null], [STRUCT,struct<field1:string,field2:int>,null], [VARCHAR,string,null], [CHAR,string,null]]
   +- DescribeTableCommand `spark_catalog`.`default`.`alltypes`, false, [col_name#4388, data_type#4389, comment#4390]

== Physical Plan ==
CommandResult [col_name#4388, data_type#4389, comment#4390]
   +- Execute DescribeTableCommand
         +- DescribeTableCommand `spark_catalog`.`default`.`alltypes`, false, [col_name#4388, data_type#4389, comment#4390]

== Parsed Logical Plan ==
'DescribeRelation false, [col_name#4361, data_type#4362, comment#4363]
+- 'UnresolvedTableOrView [default, alltypes], DESCRIBE TABLE, true

== Analyzed Logical Plan ==
col_name: string, data_type: string, comment: string
DescribeTableCommand `spark_catalog`.`default`.`alltypes`, false, [col_name#4361, data_type#4362, comment#4363]

== Optimized Logical Plan ==
CommandResult [col_name#4361, data_type#4362, comment#4363], Execute DescribeTableCommand, [[STRING,string,null], [DOUBLE,double,null], [INTEGER,int,null], [BIGINT,bigint,null], [FLOAT,float,null], [DECIMAL,decimal(10,2),null], [NUMBER,decimal(10,2),null], [BOOLEAN,boolean,null], [DATE,date,null], [TIMESTAMP,timestamp,null], [DATETIME,timestamp,null], [BINARY,binary,null], [ARRAY,array<int>,null], [MAP,map<string,string>,null], [STRUCT,struct<field1:string,field2:int>,null], [VARCHAR,string,null], [CHAR,string,null]]
   +- DescribeTableCommand `spark_catalog`.`default`.`alltypes`, false, [col_name#4361, data_type#4362, comment#4363]

== Physical Plan ==
CommandResult [col_name#4361, data_type#4362, comment#4363]
   +- Execute DescribeTableCommand
         +- DescribeTableCommand `spark_catalog`.`default`.`alltypes`, false, [col_name#4361, data_type#4362, comment#4363]

== Parsed Logical Plan ==
'GlobalLimit 5
+- 'LocalLimit 5
   +- 'Sort ['C_25 DESC NULLS LAST], true
      +- 'Project ['C_5 AS C_21#4304, 'C_6 AS C_18#4305, 'C_7 AS C_22#4306, 'C_4331 AS C_14#4307, 'C_4332 AS C_23#4308, 'C_4333 AS C_17#4309, 'C_0 AS C_20#4310, 'C_1 AS C_13#4311, 'C_43 AS C_12#4312, 'C_4 AS C_19#4313, 'C_2 AS C_24#4314, 'C_10 AS C_15#4315, 'C_11 AS C_16#4316, 'C_9 AS C_25#4317]
         +- 'SubqueryAlias C_4954424c
            +- 'Project ['C_64656661756c745f616972706f727473.id AS C_5#4288, 'C_64656661756c745f616972706f727473.type AS C_6#4289, 'C_64656661756c745f616972706f727473.name AS C_7#4290, 'C_64656661756c745f616972706f727473.lat AS C_8#4291, 'C_64656661756c745f616972706f727473.lon AS C_3#4292, 'C_64656661756c745f616972706f727473.elev AS C_9#4293, 'C_64656661756c745f616972706f727473.continent AS C_0#4294, 'C_64656661756c745f616972706f727473.country AS C_1#4295, 'C_64656661756c745f616972706f727473.region AS C_43#4296, 'C_64656661756c745f616972706f727473.city AS C_4#4297, 'C_64656661756c745f616972706f727473.iata AS C_2#4298, 'C_64656661756c745f616972706f727473.code AS C_10#4299, 'C_64656661756c745f616972706f727473.gps AS C_11#4300, ('round(('C_64656661756c745f616972706f727473.lat * 'power(10.0, 3)), 0) / 'power(10.0, 3)) AS C_4331#4301, ('round(('C_64656661756c745f616972706f727473.lon * 'power(10.0, 3)), 0) / 'power(10.0, 3)) AS C_4332#4302, ('round(('C_64656661756c745f616972706f727473.elev * 'power(10.0, 3)), 0) / 'power(10.0, 3)) AS C_4333#4303]
               +- 'Filter ((('C_64656661756c745f616972706f727473.lon <= -104.05) AND ('C_64656661756c745f616972706f727473.lon >= -111.05)) AND (('C_64656661756c745f616972706f727473.lat >= 41.0) AND ('C_64656661756c745f616972706f727473.lat <= 45.0)))
                  +- 'SubqueryAlias C_64656661756c745f616972706f727473
                     +- 'UnresolvedRelation [default, airports], [], false

== Analyzed Logical Plan ==
C_21: string, C_18: string, C_22: string, C_14: double, C_23: double, C_17: double, C_20: string, C_13: string, C_12: string, C_19: string, C_24: string, C_15: string, C_16: string, C_25: double
GlobalLimit 5
+- LocalLimit 5
   +- Sort [C_25#4317 DESC NULLS LAST], true
      +- Project [C_5#4288 AS C_21#4304, C_6#4289 AS C_18#4305, C_7#4290 AS C_22#4306, C_4331#4301 AS C_14#4307, C_4332#4302 AS C_23#4308, C_4333#4303 AS C_17#4309, C_0#4294 AS C_20#4310, C_1#4295 AS C_13#4311, C_43#4296 AS C_12#4312, C_4#4297 AS C_19#4313, C_2#4298 AS C_24#4314, C_10#4299 AS C_15#4315, C_11#4300 AS C_16#4316, C_9#4293 AS C_25#4317]
         +- SubqueryAlias C_4954424c
            +- Project [id#4318 AS C_5#4288, type#4319 AS C_6#4289, name#4320 AS C_7#4290, lat#4321 AS C_8#4291, lon#4322 AS C_3#4292, elev#4323 AS C_9#4293, continent#4324 AS C_0#4294, country#4325 AS C_1#4295, region#4326 AS C_43#4296, city#4327 AS C_4#4297, iata#4328 AS C_2#4298, code#4329 AS C_10#4299, gps#4330 AS C_11#4300, (round((lat#4321 * POWER(10.0, cast(3 as double))), 0) / POWER(10.0, cast(3 as double))) AS C_4331#4301, (round((lon#4322 * POWER(10.0, cast(3 as double))), 0) / POWER(10.0, cast(3 as double))) AS C_4332#4302, (round((elev#4323 * POWER(10.0, cast(3 as double))), 0) / POWER(10.0, cast(3 as double))) AS C_4333#4303]
               +- Filter (((lon#4322 <= -104.05) AND (lon#4322 >= -111.05)) AND ((lat#4321 >= 41.0) AND (lat#4321 <= 45.0)))
                  +- SubqueryAlias C_64656661756c745f616972706f727473
                     +- SubqueryAlias spark_catalog.default.airports
                        +- Relation spark_catalog.default.airports[id#4318,type#4319,name#4320,lat#4321,lon#4322,elev#4323,continent#4324,country#4325,region#4326,city#4327,iata#4328,code#4329,gps#4330] parquet

== Optimized Logical Plan ==
GlobalLimit 5
+- LocalLimit 5
   +- Sort [C_25#4317 DESC NULLS LAST], true
      +- Project [id#4318 AS C_21#4304, type#4319 AS C_18#4305, name#4320 AS C_22#4306, (round((lat#4321 * 1000.0), 0) / 1000.0) AS C_14#4307, (round((lon#4322 * 1000.0), 0) / 1000.0) AS C_23#4308, (round((elev#4323 * 1000.0), 0) / 1000.0) AS C_17#4309, continent#4324 AS C_20#4310, country#4325 AS C_13#4311, region#4326 AS C_12#4312, city#4327 AS C_19#4313, iata#4328 AS C_24#4314, code#4329 AS C_15#4315, gps#4330 AS C_16#4316, elev#4323 AS C_25#4317]
         +- Filter ((isnotnull(lon#4322) AND isnotnull(lat#4321)) AND (((lon#4322 <= -104.05) AND (lon#4322 >= -111.05)) AND ((lat#4321 >= 41.0) AND (lat#4321 <= 45.0))))
            +- Relation spark_catalog.default.airports[id#4318,type#4319,name#4320,lat#4321,lon#4322,elev#4323,continent#4324,country#4325,region#4326,city#4327,iata#4328,code#4329,gps#4330] parquet

== Physical Plan ==
TakeOrderedAndProject(limit=5, orderBy=[C_25#4317 DESC NULLS LAST], output=[C_21#4304,C_18#4305,C_22#4306,C_14#4307,C_23#4308,C_17#4309,C_20#4310,C_13#4311,C_12#4312,C_19#4313,C_24#4314,C_15#4315,C_16#4316,C_25#4317])
+- *(1) Project [id#4318 AS C_21#4304, type#4319 AS C_18#4305, name#4320 AS C_22#4306, (round((lat#4321 * 1000.0), 0) / 1000.0) AS C_14#4307, (round((lon#4322 * 1000.0), 0) / 1000.0) AS C_23#4308, (round((elev#4323 * 1000.0), 0) / 1000.0) AS C_17#4309, continent#4324 AS C_20#4310, country#4325 AS C_13#4311, region#4326 AS C_12#4312, city#4327 AS C_19#4313, iata#4328 AS C_24#4314, code#4329 AS C_15#4315, gps#4330 AS C_16#4316, elev#4323 AS C_25#4317]
   +- *(1) Filter (((((isnotnull(lon#4322) AND isnotnull(lat#4321)) AND (lon#4322 <= -104.05)) AND (lon#4322 >= -111.05)) AND (lat#4321 >= 41.0)) AND (lat#4321 <= 45.0))
      +- *(1) ColumnarToRow
         +- FileScan parquet spark_catalog.default.airports[id#4318,type#4319,name#4320,lat#4321,lon#4322,elev#4323,continent#4324,country#4325,region#4326,city#4327,iata#4328,code#4329,gps#4330] Batched: true, DataFilters: [isnotnull(lon#4322), isnotnull(lat#4321), (lon#4322 <= -104.05), (lon#4322 >= -111.05), (lat#432..., Format: Parquet, Location: InMemoryFileIndex(1 paths)[file:/home/acdcadmin/spark-warehouse/airports], PartitionFilters: [], PushedFilters: [IsNotNull(lon), IsNotNull(lat), LessThanOrEqual(lon,-104.05), GreaterThanOrEqual(lon,-111.05), G..., ReadSchema: struct<id:string,type:string,name:string,lat:double,lon:double,elev:double,continent:string,count...

== Parsed Logical Plan ==
'DescribeRelation false, [col_name#4265, data_type#4266, comment#4267]
+- 'UnresolvedTableOrView [default, airports], DESCRIBE TABLE, true

== Analyzed Logical Plan ==
col_name: string, data_type: string, comment: string
DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#4265, data_type#4266, comment#4267]

== Optimized Logical Plan ==
CommandResult [col_name#4265, data_type#4266, comment#4267], Execute DescribeTableCommand, [[id,string,null], [type,string,null], [name,string,null], [lat,double,null], [lon,double,null], [elev,double,null], [continent,string,null], [country,string,null], [region,string,null], [city,string,null], [iata,string,null], [code,string,null], [gps,string,null]]
   +- DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#4265, data_type#4266, comment#4267]

== Physical Plan ==
CommandResult [col_name#4265, data_type#4266, comment#4267]
   +- Execute DescribeTableCommand
         +- DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#4265, data_type#4266, comment#4267]

== Parsed Logical Plan ==
'DescribeRelation false, [col_name#4242, data_type#4243, comment#4244]
+- 'UnresolvedTableOrView [default, airports], DESCRIBE TABLE, true

== Analyzed Logical Plan ==
col_name: string, data_type: string, comment: string
DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#4242, data_type#4243, comment#4244]

== Optimized Logical Plan ==
CommandResult [col_name#4242, data_type#4243, comment#4244], Execute DescribeTableCommand, [[id,string,null], [type,string,null], [name,string,null], [lat,double,null], [lon,double,null], [elev,double,null], [continent,string,null], [country,string,null], [region,string,null], [city,string,null], [iata,string,null], [code,string,null], [gps,string,null]]
   +- DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#4242, data_type#4243, comment#4244]

== Physical Plan ==
CommandResult [col_name#4242, data_type#4243, comment#4244]
   +- Execute DescribeTableCommand
         +- DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#4242, data_type#4243, comment#4244]

== Parsed Logical Plan ==
SetCommand (-v,None)

== Analyzed Logical Plan ==
key: string, value: string, meaning: string, Since version: string
SetCommand (-v,None)

== Optimized Logical Plan ==
CommandResult [key#4217, value#4218, meaning#4219, Since version#4220], Execute SetCommand, [[spark.sql.adaptive.advisoryPartitionSizeInBytes,<value of spark.sql.adaptive.shuffle.targetPostShuffleInputSize>,The advisory size in bytes of the shuffle partition during adaptive optimization (when spark.sql.adaptive.enabled is true). It takes effect when Spark coalesces small shuffle partitions or splits skewed shuffle partition.,3.0.0], [spark.sql.adaptive.autoBroadcastJoinThreshold,<undefined>,Configures the maximum size in bytes for a table that will be broadcast to all worker nodes when performing a join. By setting this value to -1 broadcasting can be disabled. The default value is same with spark.sql.autoBroadcastJoinThreshold. Note that, this config is used only in adaptive framework.,3.2.0], [spark.sql.adaptive.coalescePartitions.enabled,true,When true and 'spark.sql.adaptive.enabled' is true, Spark will coalesce contiguous shuffle partitions according to the target size (specified by 'spark.sql.adaptive.advisoryPartitionSizeInBytes'), to avoid too many small tasks.,3.0.0], [spark.sql.adaptive.coalescePartitions.initialPartitionNum,<undefined>,The initial number of shuffle partitions before coalescing. If not set, it equals to spark.sql.shuffle.partitions. This configuration only has an effect when 'spark.sql.adaptive.enabled' and 'spark.sql.adaptive.coalescePartitions.enabled' are both true.,3.0.0], [spark.sql.adaptive.coalescePartitions.minPartitionSize,1MB,The minimum size of shuffle partitions after coalescing. This is useful when the adaptively calculated target size is too small during partition coalescing.,3.2.0], [spark.sql.adaptive.coalescePartitions.parallelismFirst,true,When true, Spark does not respect the target size specified by 'spark.sql.adaptive.advisoryPartitionSizeInBytes' (default 64MB) when coalescing contiguous shuffle partitions, but adaptively calculate the target size according to the default parallelism of the Spark cluster. The calculated size is usually smaller than the configured target size. This is to maximize the parallelism and avoid performance regression when enabling adaptive query execution. It's recommended to set this config to false and respect the configured target size.,3.2.0], [spark.sql.adaptive.customCostEvaluatorClass,<undefined>,The custom cost evaluator class to be used for adaptive execution. If not being set, Spark will use its own SimpleCostEvaluator by default.,3.2.0], [spark.sql.adaptive.enabled,true,When true, enable adaptive query execution, which re-optimizes the query plan in the middle of query execution, based on accurate runtime statistics.,1.6.0], [spark.sql.adaptive.forceOptimizeSkewedJoin,false,When true, force enable OptimizeSkewedJoin even if it introduces extra shuffle.,3.3.0], [spark.sql.adaptive.localShuffleReader.enabled,true,When true and 'spark.sql.adaptive.enabled' is true, Spark tries to use local shuffle reader to read the shuffle data when the shuffle partitioning is not needed, for example, after converting sort-merge join to broadcast-hash join.,3.0.0], [spark.sql.adaptive.maxShuffledHashJoinLocalMapThreshold,0b,Configures the maximum size in bytes per partition that can be allowed to build local hash map. If this value is not smaller than spark.sql.adaptive.advisoryPartitionSizeInBytes and all the partition size are not larger than this config, join selection prefer to use shuffled hash join instead of sort merge join regardless of the value of spark.sql.join.preferSortMergeJoin.,3.2.0], [spark.sql.adaptive.optimizeSkewsInRebalancePartitions.enabled,true,When true and 'spark.sql.adaptive.enabled' is true, Spark will optimize the skewed shuffle partitions in RebalancePartitions and split them to smaller ones according to the target size (specified by 'spark.sql.adaptive.advisoryPartitionSizeInBytes'), to avoid data skew.,3.2.0], [spark.sql.adaptive.optimizer.excludedRules,<undefined>,Configures a list of rules to be disabled in the adaptive optimizer, in which the rules are specified by their rule names and separated by comma. The optimizer will log the rules that have indeed been excluded.,3.1.0], [spark.sql.adaptive.rebalancePartitionsSmallPartitionFactor,0.2,A partition will be merged during splitting if its size is small than this factor multiply spark.sql.adaptive.advisoryPartitionSizeInBytes.,3.3.0], [spark.sql.adaptive.skewJoin.enabled,true,When true and 'spark.sql.adaptive.enabled' is true, Spark dynamically handles skew in shuffled join (sort-merge and shuffled hash) by splitting (and replicating if needed) skewed partitions.,3.0.0], [spark.sql.adaptive.skewJoin.skewedPartitionFactor,5.0,A partition is considered as skewed if its size is larger than this factor multiplying the median partition size and also larger than 'spark.sql.adaptive.skewJoin.skewedPartitionThresholdInBytes',3.0.0], [spark.sql.adaptive.skewJoin.skewedPartitionThresholdInBytes,256MB,A partition is considered as skewed if its size in bytes is larger than this threshold and also larger than 'spark.sql.adaptive.skewJoin.skewedPartitionFactor' multiplying the median partition size. Ideally this config should be set larger than 'spark.sql.adaptive.advisoryPartitionSizeInBytes'.,3.0.0], [spark.sql.allowNamedFunctionArguments,true,If true, Spark will turn on support for named parameters for all functions that has it implemented.,3.5.0], [spark.sql.ansi.doubleQuotedIdentifiers,false,When true and 'spark.sql.ansi.enabled' is true, Spark SQL reads literals enclosed in double quoted (") as identifiers. When false they are read as string literals.,3.4.0], [spark.sql.ansi.enabled,false,When true, Spark SQL uses an ANSI compliant dialect instead of being Hive compliant. For example, Spark will throw an exception at runtime instead of returning null results when the inputs to a SQL operator/function are invalid.For full details of this dialect, you can find them in the section "ANSI Compliance" of Spark's documentation. Some ANSI dialect features may be not from the ANSI SQL standard directly, but their behaviors align with ANSI SQL's style,3.0.0], [spark.sql.ansi.enforceReservedKeywords,false,When true and 'spark.sql.ansi.enabled' is true, the Spark SQL parser enforces the ANSI reserved keywords and forbids SQL queries that use reserved keywords as alias names and/or identifiers for table, view, function, etc.,3.3.0], [spark.sql.ansi.relationPrecedence,false,When true and 'spark.sql.ansi.enabled' is true, JOIN takes precedence over comma when combining relation. For example, `t1, t2 JOIN t3` should result to `t1 X (t2 X t3)`. If the config is false, the result is `(t1 X t2) X t3`.,3.4.0], [spark.sql.autoBroadcastJoinThreshold,10MB,Configures the maximum size in bytes for a table that will be broadcast to all worker nodes when performing a join.  By setting this value to -1 broadcasting can be disabled. Note that currently statistics are only supported for Hive Metastore tables where the command `ANALYZE TABLE <tableName> COMPUTE STATISTICS noscan` has been run, and file-based data source tables where the statistics are computed directly on the files of data.,1.1.0], [spark.sql.avro.compression.codec,snappy,Compression codec used in writing of AVRO files. Supported codecs: uncompressed, deflate, snappy, bzip2, xz and zstandard. Default codec is snappy.,2.4.0], ... 183 more fields]
   +- SetCommand (-v,None)

== Physical Plan ==
CommandResult [key#4217, value#4218, meaning#4219, Since version#4220]
   +- Execute SetCommand
         +- SetCommand (-v,None)

== Parsed Logical Plan ==
'DescribeRelation false, [col_name#4190, data_type#4191, comment#4192]
+- 'UnresolvedTableOrView [default, alltypes], DESCRIBE TABLE, true

== Analyzed Logical Plan ==
col_name: string, data_type: string, comment: string
DescribeTableCommand `spark_catalog`.`default`.`alltypes`, false, [col_name#4190, data_type#4191, comment#4192]

== Optimized Logical Plan ==
CommandResult [col_name#4190, data_type#4191, comment#4192], Execute DescribeTableCommand, [[STRING,string,null], [DOUBLE,double,null], [INTEGER,int,null], [BIGINT,bigint,null], [FLOAT,float,null], [DECIMAL,decimal(10,2),null], [NUMBER,decimal(10,2),null], [BOOLEAN,boolean,null], [DATE,date,null], [TIMESTAMP,timestamp,null], [DATETIME,timestamp,null], [BINARY,binary,null], [ARRAY,array<int>,null], [MAP,map<string,string>,null], [STRUCT,struct<field1:string,field2:int>,null], [VARCHAR,string,null], [CHAR,string,null]]
   +- DescribeTableCommand `spark_catalog`.`default`.`alltypes`, false, [col_name#4190, data_type#4191, comment#4192]

== Physical Plan ==
CommandResult [col_name#4190, data_type#4191, comment#4192]
   +- Execute DescribeTableCommand
         +- DescribeTableCommand `spark_catalog`.`default`.`alltypes`, false, [col_name#4190, data_type#4191, comment#4192]

== Parsed Logical Plan ==
'DescribeRelation false, [col_name#4163, data_type#4164, comment#4165]
+- 'UnresolvedTableOrView [default, alltypes], DESCRIBE TABLE, true

== Analyzed Logical Plan ==
col_name: string, data_type: string, comment: string
DescribeTableCommand `spark_catalog`.`default`.`alltypes`, false, [col_name#4163, data_type#4164, comment#4165]

== Optimized Logical Plan ==
CommandResult [col_name#4163, data_type#4164, comment#4165], Execute DescribeTableCommand, [[STRING,string,null], [DOUBLE,double,null], [INTEGER,int,null], [BIGINT,bigint,null], [FLOAT,float,null], [DECIMAL,decimal(10,2),null], [NUMBER,decimal(10,2),null], [BOOLEAN,boolean,null], [DATE,date,null], [TIMESTAMP,timestamp,null], [DATETIME,timestamp,null], [BINARY,binary,null], [ARRAY,array<int>,null], [MAP,map<string,string>,null], [STRUCT,struct<field1:string,field2:int>,null], [VARCHAR,string,null], [CHAR,string,null]]
   +- DescribeTableCommand `spark_catalog`.`default`.`alltypes`, false, [col_name#4163, data_type#4164, comment#4165]

== Physical Plan ==
CommandResult [col_name#4163, data_type#4164, comment#4165]
   +- Execute DescribeTableCommand
         +- DescribeTableCommand `spark_catalog`.`default`.`alltypes`, false, [col_name#4163, data_type#4164, comment#4165]

== Parsed Logical Plan ==
SetCommand (-v,None)

== Analyzed Logical Plan ==
key: string, value: string, meaning: string, Since version: string
SetCommand (-v,None)

== Optimized Logical Plan ==
CommandResult [key#4138, value#4139, meaning#4140, Since version#4141], Execute SetCommand, [[spark.sql.adaptive.advisoryPartitionSizeInBytes,<value of spark.sql.adaptive.shuffle.targetPostShuffleInputSize>,The advisory size in bytes of the shuffle partition during adaptive optimization (when spark.sql.adaptive.enabled is true). It takes effect when Spark coalesces small shuffle partitions or splits skewed shuffle partition.,3.0.0], [spark.sql.adaptive.autoBroadcastJoinThreshold,<undefined>,Configures the maximum size in bytes for a table that will be broadcast to all worker nodes when performing a join. By setting this value to -1 broadcasting can be disabled. The default value is same with spark.sql.autoBroadcastJoinThreshold. Note that, this config is used only in adaptive framework.,3.2.0], [spark.sql.adaptive.coalescePartitions.enabled,true,When true and 'spark.sql.adaptive.enabled' is true, Spark will coalesce contiguous shuffle partitions according to the target size (specified by 'spark.sql.adaptive.advisoryPartitionSizeInBytes'), to avoid too many small tasks.,3.0.0], [spark.sql.adaptive.coalescePartitions.initialPartitionNum,<undefined>,The initial number of shuffle partitions before coalescing. If not set, it equals to spark.sql.shuffle.partitions. This configuration only has an effect when 'spark.sql.adaptive.enabled' and 'spark.sql.adaptive.coalescePartitions.enabled' are both true.,3.0.0], [spark.sql.adaptive.coalescePartitions.minPartitionSize,1MB,The minimum size of shuffle partitions after coalescing. This is useful when the adaptively calculated target size is too small during partition coalescing.,3.2.0], [spark.sql.adaptive.coalescePartitions.parallelismFirst,true,When true, Spark does not respect the target size specified by 'spark.sql.adaptive.advisoryPartitionSizeInBytes' (default 64MB) when coalescing contiguous shuffle partitions, but adaptively calculate the target size according to the default parallelism of the Spark cluster. The calculated size is usually smaller than the configured target size. This is to maximize the parallelism and avoid performance regression when enabling adaptive query execution. It's recommended to set this config to false and respect the configured target size.,3.2.0], [spark.sql.adaptive.customCostEvaluatorClass,<undefined>,The custom cost evaluator class to be used for adaptive execution. If not being set, Spark will use its own SimpleCostEvaluator by default.,3.2.0], [spark.sql.adaptive.enabled,true,When true, enable adaptive query execution, which re-optimizes the query plan in the middle of query execution, based on accurate runtime statistics.,1.6.0], [spark.sql.adaptive.forceOptimizeSkewedJoin,false,When true, force enable OptimizeSkewedJoin even if it introduces extra shuffle.,3.3.0], [spark.sql.adaptive.localShuffleReader.enabled,true,When true and 'spark.sql.adaptive.enabled' is true, Spark tries to use local shuffle reader to read the shuffle data when the shuffle partitioning is not needed, for example, after converting sort-merge join to broadcast-hash join.,3.0.0], [spark.sql.adaptive.maxShuffledHashJoinLocalMapThreshold,0b,Configures the maximum size in bytes per partition that can be allowed to build local hash map. If this value is not smaller than spark.sql.adaptive.advisoryPartitionSizeInBytes and all the partition size are not larger than this config, join selection prefer to use shuffled hash join instead of sort merge join regardless of the value of spark.sql.join.preferSortMergeJoin.,3.2.0], [spark.sql.adaptive.optimizeSkewsInRebalancePartitions.enabled,true,When true and 'spark.sql.adaptive.enabled' is true, Spark will optimize the skewed shuffle partitions in RebalancePartitions and split them to smaller ones according to the target size (specified by 'spark.sql.adaptive.advisoryPartitionSizeInBytes'), to avoid data skew.,3.2.0], [spark.sql.adaptive.optimizer.excludedRules,<undefined>,Configures a list of rules to be disabled in the adaptive optimizer, in which the rules are specified by their rule names and separated by comma. The optimizer will log the rules that have indeed been excluded.,3.1.0], [spark.sql.adaptive.rebalancePartitionsSmallPartitionFactor,0.2,A partition will be merged during splitting if its size is small than this factor multiply spark.sql.adaptive.advisoryPartitionSizeInBytes.,3.3.0], [spark.sql.adaptive.skewJoin.enabled,true,When true and 'spark.sql.adaptive.enabled' is true, Spark dynamically handles skew in shuffled join (sort-merge and shuffled hash) by splitting (and replicating if needed) skewed partitions.,3.0.0], [spark.sql.adaptive.skewJoin.skewedPartitionFactor,5.0,A partition is considered as skewed if its size is larger than this factor multiplying the median partition size and also larger than 'spark.sql.adaptive.skewJoin.skewedPartitionThresholdInBytes',3.0.0], [spark.sql.adaptive.skewJoin.skewedPartitionThresholdInBytes,256MB,A partition is considered as skewed if its size in bytes is larger than this threshold and also larger than 'spark.sql.adaptive.skewJoin.skewedPartitionFactor' multiplying the median partition size. Ideally this config should be set larger than 'spark.sql.adaptive.advisoryPartitionSizeInBytes'.,3.0.0], [spark.sql.allowNamedFunctionArguments,true,If true, Spark will turn on support for named parameters for all functions that has it implemented.,3.5.0], [spark.sql.ansi.doubleQuotedIdentifiers,false,When true and 'spark.sql.ansi.enabled' is true, Spark SQL reads literals enclosed in double quoted (") as identifiers. When false they are read as string literals.,3.4.0], [spark.sql.ansi.enabled,false,When true, Spark SQL uses an ANSI compliant dialect instead of being Hive compliant. For example, Spark will throw an exception at runtime instead of returning null results when the inputs to a SQL operator/function are invalid.For full details of this dialect, you can find them in the section "ANSI Compliance" of Spark's documentation. Some ANSI dialect features may be not from the ANSI SQL standard directly, but their behaviors align with ANSI SQL's style,3.0.0], [spark.sql.ansi.enforceReservedKeywords,false,When true and 'spark.sql.ansi.enabled' is true, the Spark SQL parser enforces the ANSI reserved keywords and forbids SQL queries that use reserved keywords as alias names and/or identifiers for table, view, function, etc.,3.3.0], [spark.sql.ansi.relationPrecedence,false,When true and 'spark.sql.ansi.enabled' is true, JOIN takes precedence over comma when combining relation. For example, `t1, t2 JOIN t3` should result to `t1 X (t2 X t3)`. If the config is false, the result is `(t1 X t2) X t3`.,3.4.0], [spark.sql.autoBroadcastJoinThreshold,10MB,Configures the maximum size in bytes for a table that will be broadcast to all worker nodes when performing a join.  By setting this value to -1 broadcasting can be disabled. Note that currently statistics are only supported for Hive Metastore tables where the command `ANALYZE TABLE <tableName> COMPUTE STATISTICS noscan` has been run, and file-based data source tables where the statistics are computed directly on the files of data.,1.1.0], [spark.sql.avro.compression.codec,snappy,Compression codec used in writing of AVRO files. Supported codecs: uncompressed, deflate, snappy, bzip2, xz and zstandard. Default codec is snappy.,2.4.0], ... 183 more fields]
   +- SetCommand (-v,None)

== Physical Plan ==
CommandResult [key#4138, value#4139, meaning#4140, Since version#4141]
   +- Execute SetCommand
         +- SetCommand (-v,None)

== Parsed Logical Plan ==
'ShowTables [namespace#4128, tableName#4129, isTemporary#4130]
+- 'UnresolvedNamespace [global_temp]

== Analyzed Logical Plan ==
namespace: string, tableName: string, isTemporary: boolean
ShowTables [namespace#4128, tableName#4129, isTemporary#4130]
+- ResolvedNamespace V2SessionCatalog(spark_catalog), [global_temp]

== Optimized Logical Plan ==
CommandResult [namespace#4128, tableName#4129, isTemporary#4130], ShowTables [namespace#4128, tableName#4129, isTemporary#4130], V2SessionCatalog(spark_catalog), [global_temp]
   +- ShowTables [namespace#4128, tableName#4129, isTemporary#4130]
      +- ResolvedNamespace V2SessionCatalog(spark_catalog), [global_temp]

== Physical Plan ==
CommandResult <empty>, [namespace#4128, tableName#4129, isTemporary#4130]
   +- ShowTables [namespace#4128, tableName#4129, isTemporary#4130], V2SessionCatalog(spark_catalog), [global_temp]

== Parsed Logical Plan ==
'ShowTables [namespace#4118, tableName#4119, isTemporary#4120]
+- 'UnresolvedNamespace [test]

== Analyzed Logical Plan ==
namespace: string, tableName: string, isTemporary: boolean
ShowTables [namespace#4118, tableName#4119, isTemporary#4120]
+- ResolvedNamespace V2SessionCatalog(spark_catalog), [test]

== Optimized Logical Plan ==
CommandResult [namespace#4118, tableName#4119, isTemporary#4120], ShowTables [namespace#4118, tableName#4119, isTemporary#4120], V2SessionCatalog(spark_catalog), [test]
   +- ShowTables [namespace#4118, tableName#4119, isTemporary#4120]
      +- ResolvedNamespace V2SessionCatalog(spark_catalog), [test]

== Physical Plan ==
CommandResult <empty>, [namespace#4118, tableName#4119, isTemporary#4120]
   +- ShowTables [namespace#4118, tableName#4119, isTemporary#4120], V2SessionCatalog(spark_catalog), [test]

== Parsed Logical Plan ==
'ShowTables [namespace#4098, tableName#4099, isTemporary#4100]
+- 'UnresolvedNamespace [onetableschema]

== Analyzed Logical Plan ==
namespace: string, tableName: string, isTemporary: boolean
ShowTables [namespace#4098, tableName#4099, isTemporary#4100]
+- ResolvedNamespace V2SessionCatalog(spark_catalog), [onetableschema]

== Optimized Logical Plan ==
CommandResult [namespace#4098, tableName#4099, isTemporary#4100], ShowTables [namespace#4098, tableName#4099, isTemporary#4100], V2SessionCatalog(spark_catalog), [onetableschema], [[0,200000000e,300000000c,0,656c626174656e6f,616d65686373,73657079746c6c61,74736574]]
   +- ShowTables [namespace#4098, tableName#4099, isTemporary#4100]
      +- ResolvedNamespace V2SessionCatalog(spark_catalog), [onetableschema]

== Physical Plan ==
CommandResult [namespace#4098, tableName#4099, isTemporary#4100]
   +- ShowTables [namespace#4098, tableName#4099, isTemporary#4100], V2SessionCatalog(spark_catalog), [onetableschema]

== Parsed Logical Plan ==
'ShowTables [namespace#4078, tableName#4079, isTemporary#4080]
+- 'UnresolvedNamespace [default]

== Analyzed Logical Plan ==
namespace: string, tableName: string, isTemporary: boolean
ShowTables [namespace#4078, tableName#4079, isTemporary#4080]
+- ResolvedNamespace V2SessionCatalog(spark_catalog), [default]

== Optimized Logical Plan ==
CommandResult [namespace#4078, tableName#4079, isTemporary#4080], ShowTables [namespace#4078, tableName#4079, isTemporary#4080], V2SessionCatalog(spark_catalog), [default], [[0,2000000007,2800000008,0,746c7561666564,7374726f70726961], [0,2000000007,2800000008,0,746c7561666564,73657079746c6c61], [0,2000000007,2800000009,0,746c7561666564,73657079746c6c61,32], [0,2000000007,280000000d,0,746c7561666564,73657079746c6c61,6369736162], [0,2000000007,280000000e,0,746c7561666564,73657079746c6c61,326369736162], [0,2000000007,2800000009,0,746c7561666564,7079747961727261,65], [0,2000000007,280000000a,0,746c7561666564,7974746e69676962,6570], [0,2000000007,280000000a,0,746c7561666564,79747972616e6962,6570], [0,2000000007,2800000008,0,746c7561666564,6570797465746164], [0,2000000007,280000000b,0,746c7561666564,746c616d69636564,657079], [0,2000000007,2800000009,0,746c7561666564,70797474616f6c66,65], [0,2000000007,2800000008,0,746c7561666564,736570797470616d], [0,2000000007,280000000b,0,746c7561666564,646978617463796e,617461], [0,2000000007,280000000f,0,746c7561666564,746978617463796e,61746164706972], [0,2000000007,2800000010,0,746c7561666564,7365745f656d6f73,32656c6261745f74], [0,2000000007,280000000a,0,746c7561666564,7974746375727473,6570], [0,2000000007,280000000e,0,746c7561666564,656e6f7a69786174,70756b6f6f6c], [0,2000000007,280000000c,0,746c7561666564,74676e696b726f77,73657079], [0,2000000007,2800000016,0,746c7561666564,74676e696b726f77,6874697773657079,7265626d756e]]
   +- ShowTables [namespace#4078, tableName#4079, isTemporary#4080]
      +- ResolvedNamespace V2SessionCatalog(spark_catalog), [default]

== Physical Plan ==
CommandResult [namespace#4078, tableName#4079, isTemporary#4080]
   +- ShowTables [namespace#4078, tableName#4079, isTemporary#4080], V2SessionCatalog(spark_catalog), [default]

== Parsed Logical Plan ==
'ShowTables [namespace#4058, tableName#4059, isTemporary#4060]
+- 'UnresolvedNamespace [c3ba675f1fb64660ba4a90155b35924e]

== Analyzed Logical Plan ==
namespace: string, tableName: string, isTemporary: boolean
ShowTables [namespace#4058, tableName#4059, isTemporary#4060]
+- ResolvedNamespace V2SessionCatalog(spark_catalog), [c3ba675f1fb64660ba4a90155b35924e]

== Optimized Logical Plan ==
CommandResult [namespace#4058, tableName#4059, isTemporary#4060], ShowTables [namespace#4058, tableName#4059, isTemporary#4060], V2SessionCatalog(spark_catalog), [c3ba675f1fb64660ba4a90155b35924e], [[0,2000000020,400000000c,0,6635373661623363,3036363436626631,3531303961346162,6534323935336235,69746e656469796d,72656966]]
   +- ShowTables [namespace#4058, tableName#4059, isTemporary#4060]
      +- ResolvedNamespace V2SessionCatalog(spark_catalog), [c3ba675f1fb64660ba4a90155b35924e]

== Physical Plan ==
CommandResult [namespace#4058, tableName#4059, isTemporary#4060]
   +- ShowTables [namespace#4058, tableName#4059, isTemporary#4060], V2SessionCatalog(spark_catalog), [c3ba675f1fb64660ba4a90155b35924e]

== Parsed Logical Plan ==
'GlobalLimit 1000
+- 'LocalLimit 1000
   +- 'Project ['STRING, 'DOUBLE, 'INTEGER, 'BIGINT, 'FLOAT, 'DECIMAL, 'NUMBER, 'BOOLEAN, 'DATE, 'TIMESTAMP, 'DATETIME, 'BINARY, 'ARRAY, 'MAP, 'STRUCT, 'VARCHAR, 'CHAR]
      +- 'UnresolvedRelation [default, alltypes], [], false

== Analyzed Logical Plan ==
STRING: string, DOUBLE: double, INTEGER: int, BIGINT: bigint, FLOAT: float, DECIMAL: decimal(10,2), NUMBER: decimal(10,2), BOOLEAN: boolean, DATE: date, TIMESTAMP: timestamp, DATETIME: timestamp, BINARY: binary, ARRAY: array<int>, MAP: map<string,string>, STRUCT: struct<field1:string,field2:int>, VARCHAR: string, CHAR: string
GlobalLimit 1000
+- LocalLimit 1000
   +- Project [STRING#4006, DOUBLE#4007, INTEGER#4008, BIGINT#4009L, FLOAT#4010, DECIMAL#4011, NUMBER#4012, BOOLEAN#4013, DATE#4014, TIMESTAMP#4015, DATETIME#4016, BINARY#4017, ARRAY#4018, MAP#4019, STRUCT#4020, VARCHAR#4021, CHAR#4022]
      +- SubqueryAlias spark_catalog.default.alltypes
         +- HiveTableRelation [`spark_catalog`.`default`.`alltypes`, org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe, Data Cols: [STRING#4006, DOUBLE#4007, INTEGER#4008, BIGINT#4009L, FLOAT#4010, DECIMAL#4011, NUMBER#4012, BOO..., Partition Cols: []]

== Optimized Logical Plan ==
GlobalLimit 1000
+- LocalLimit 1000
   +- HiveTableRelation [`spark_catalog`.`default`.`alltypes`, org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe, Data Cols: [STRING#4006, DOUBLE#4007, INTEGER#4008, BIGINT#4009L, FLOAT#4010, DECIMAL#4011, NUMBER#4012, BOO..., Partition Cols: []]

== Physical Plan ==
CollectLimit 1000
+- Scan hive spark_catalog.default.alltypes [STRING#4006, DOUBLE#4007, INTEGER#4008, BIGINT#4009L, FLOAT#4010, DECIMAL#4011, NUMBER#4012, BOOLEAN#4013, DATE#4014, TIMESTAMP#4015, DATETIME#4016, BINARY#4017, ARRAY#4018, MAP#4019, STRUCT#4020, VARCHAR#4021, CHAR#4022], HiveTableRelation [`spark_catalog`.`default`.`alltypes`, org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe, Data Cols: [STRING#4006, DOUBLE#4007, INTEGER#4008, BIGINT#4009L, FLOAT#4010, DECIMAL#4011, NUMBER#4012, BOO..., Partition Cols: []]

== Parsed Logical Plan ==
'DescribeRelation false, [col_name#3979, data_type#3980, comment#3981]
+- 'UnresolvedTableOrView [default, alltypes], DESCRIBE TABLE, true

== Analyzed Logical Plan ==
col_name: string, data_type: string, comment: string
DescribeTableCommand `spark_catalog`.`default`.`alltypes`, false, [col_name#3979, data_type#3980, comment#3981]

== Optimized Logical Plan ==
CommandResult [col_name#3979, data_type#3980, comment#3981], Execute DescribeTableCommand, [[STRING,string,null], [DOUBLE,double,null], [INTEGER,int,null], [BIGINT,bigint,null], [FLOAT,float,null], [DECIMAL,decimal(10,2),null], [NUMBER,decimal(10,2),null], [BOOLEAN,boolean,null], [DATE,date,null], [TIMESTAMP,timestamp,null], [DATETIME,timestamp,null], [BINARY,binary,null], [ARRAY,array<int>,null], [MAP,map<string,string>,null], [STRUCT,struct<field1:string,field2:int>,null], [VARCHAR,string,null], [CHAR,string,null]]
   +- DescribeTableCommand `spark_catalog`.`default`.`alltypes`, false, [col_name#3979, data_type#3980, comment#3981]

== Physical Plan ==
CommandResult [col_name#3979, data_type#3980, comment#3981]
   +- Execute DescribeTableCommand
         +- DescribeTableCommand `spark_catalog`.`default`.`alltypes`, false, [col_name#3979, data_type#3980, comment#3981]

== Parsed Logical Plan ==
'DescribeRelation false, [col_name#3952, data_type#3953, comment#3954]
+- 'UnresolvedTableOrView [default, alltypes], DESCRIBE TABLE, true

== Analyzed Logical Plan ==
col_name: string, data_type: string, comment: string
DescribeTableCommand `spark_catalog`.`default`.`alltypes`, false, [col_name#3952, data_type#3953, comment#3954]

== Optimized Logical Plan ==
CommandResult [col_name#3952, data_type#3953, comment#3954], Execute DescribeTableCommand, [[STRING,string,null], [DOUBLE,double,null], [INTEGER,int,null], [BIGINT,bigint,null], [FLOAT,float,null], [DECIMAL,decimal(10,2),null], [NUMBER,decimal(10,2),null], [BOOLEAN,boolean,null], [DATE,date,null], [TIMESTAMP,timestamp,null], [DATETIME,timestamp,null], [BINARY,binary,null], [ARRAY,array<int>,null], [MAP,map<string,string>,null], [STRUCT,struct<field1:string,field2:int>,null], [VARCHAR,string,null], [CHAR,string,null]]
   +- DescribeTableCommand `spark_catalog`.`default`.`alltypes`, false, [col_name#3952, data_type#3953, comment#3954]

== Physical Plan ==
CommandResult [col_name#3952, data_type#3953, comment#3954]
   +- Execute DescribeTableCommand
         +- DescribeTableCommand `spark_catalog`.`default`.`alltypes`, false, [col_name#3952, data_type#3953, comment#3954]

== Parsed Logical Plan ==
'GlobalLimit 5
+- 'LocalLimit 5
   +- 'Sort ['C_24 DESC NULLS LAST], true
      +- 'Project ['C_1 AS C_20#3895, 'C_2 AS C_18#3896, 'C_3 AS C_21#3897, 'C_4331 AS C_22#3898, 'C_4332 AS C_25#3899, 'C_4333 AS C_19#3900, 'C_0 AS C_17#3901, 'C_43 AS C_12#3902, 'C_10 AS C_15#3903, 'C_8 AS C_23#3904, 'C_7 AS C_13#3905, 'C_9 AS C_16#3906, 'C_11 AS C_14#3907, 'C_6 AS C_24#3908]
         +- 'SubqueryAlias C_4954424c
            +- 'Project ['C_64656661756c745f616972706f727473.id AS C_1#3879, 'C_64656661756c745f616972706f727473.type AS C_2#3880, 'C_64656661756c745f616972706f727473.name AS C_3#3881, 'C_64656661756c745f616972706f727473.lat AS C_4#3882, 'C_64656661756c745f616972706f727473.lon AS C_5#3883, 'C_64656661756c745f616972706f727473.elev AS C_6#3884, 'C_64656661756c745f616972706f727473.continent AS C_0#3885, 'C_64656661756c745f616972706f727473.country AS C_43#3886, 'C_64656661756c745f616972706f727473.region AS C_10#3887, 'C_64656661756c745f616972706f727473.city AS C_8#3888, 'C_64656661756c745f616972706f727473.iata AS C_7#3889, 'C_64656661756c745f616972706f727473.code AS C_9#3890, 'C_64656661756c745f616972706f727473.gps AS C_11#3891, ('round(('C_64656661756c745f616972706f727473.lat * 'power(10.0, 3)), 0) / 'power(10.0, 3)) AS C_4331#3892, ('round(('C_64656661756c745f616972706f727473.lon * 'power(10.0, 3)), 0) / 'power(10.0, 3)) AS C_4332#3893, ('round(('C_64656661756c745f616972706f727473.elev * 'power(10.0, 3)), 0) / 'power(10.0, 3)) AS C_4333#3894]
               +- 'Filter ((('C_64656661756c745f616972706f727473.lon <= -104.05) AND ('C_64656661756c745f616972706f727473.lon >= -111.05)) AND (('C_64656661756c745f616972706f727473.lat >= 41.0) AND ('C_64656661756c745f616972706f727473.lat <= 45.0)))
                  +- 'SubqueryAlias C_64656661756c745f616972706f727473
                     +- 'UnresolvedRelation [default, airports], [], false

== Analyzed Logical Plan ==
C_20: string, C_18: string, C_21: string, C_22: double, C_25: double, C_19: double, C_17: string, C_12: string, C_15: string, C_23: string, C_13: string, C_16: string, C_14: string, C_24: double
GlobalLimit 5
+- LocalLimit 5
   +- Sort [C_24#3908 DESC NULLS LAST], true
      +- Project [C_1#3879 AS C_20#3895, C_2#3880 AS C_18#3896, C_3#3881 AS C_21#3897, C_4331#3892 AS C_22#3898, C_4332#3893 AS C_25#3899, C_4333#3894 AS C_19#3900, C_0#3885 AS C_17#3901, C_43#3886 AS C_12#3902, C_10#3887 AS C_15#3903, C_8#3888 AS C_23#3904, C_7#3889 AS C_13#3905, C_9#3890 AS C_16#3906, C_11#3891 AS C_14#3907, C_6#3884 AS C_24#3908]
         +- SubqueryAlias C_4954424c
            +- Project [id#3909 AS C_1#3879, type#3910 AS C_2#3880, name#3911 AS C_3#3881, lat#3912 AS C_4#3882, lon#3913 AS C_5#3883, elev#3914 AS C_6#3884, continent#3915 AS C_0#3885, country#3916 AS C_43#3886, region#3917 AS C_10#3887, city#3918 AS C_8#3888, iata#3919 AS C_7#3889, code#3920 AS C_9#3890, gps#3921 AS C_11#3891, (round((lat#3912 * POWER(10.0, cast(3 as double))), 0) / POWER(10.0, cast(3 as double))) AS C_4331#3892, (round((lon#3913 * POWER(10.0, cast(3 as double))), 0) / POWER(10.0, cast(3 as double))) AS C_4332#3893, (round((elev#3914 * POWER(10.0, cast(3 as double))), 0) / POWER(10.0, cast(3 as double))) AS C_4333#3894]
               +- Filter (((lon#3913 <= -104.05) AND (lon#3913 >= -111.05)) AND ((lat#3912 >= 41.0) AND (lat#3912 <= 45.0)))
                  +- SubqueryAlias C_64656661756c745f616972706f727473
                     +- SubqueryAlias spark_catalog.default.airports
                        +- Relation spark_catalog.default.airports[id#3909,type#3910,name#3911,lat#3912,lon#3913,elev#3914,continent#3915,country#3916,region#3917,city#3918,iata#3919,code#3920,gps#3921] parquet

== Optimized Logical Plan ==
GlobalLimit 5
+- LocalLimit 5
   +- Sort [C_24#3908 DESC NULLS LAST], true
      +- Project [id#3909 AS C_20#3895, type#3910 AS C_18#3896, name#3911 AS C_21#3897, (round((lat#3912 * 1000.0), 0) / 1000.0) AS C_22#3898, (round((lon#3913 * 1000.0), 0) / 1000.0) AS C_25#3899, (round((elev#3914 * 1000.0), 0) / 1000.0) AS C_19#3900, continent#3915 AS C_17#3901, country#3916 AS C_12#3902, region#3917 AS C_15#3903, city#3918 AS C_23#3904, iata#3919 AS C_13#3905, code#3920 AS C_16#3906, gps#3921 AS C_14#3907, elev#3914 AS C_24#3908]
         +- Filter ((isnotnull(lon#3913) AND isnotnull(lat#3912)) AND (((lon#3913 <= -104.05) AND (lon#3913 >= -111.05)) AND ((lat#3912 >= 41.0) AND (lat#3912 <= 45.0))))
            +- Relation spark_catalog.default.airports[id#3909,type#3910,name#3911,lat#3912,lon#3913,elev#3914,continent#3915,country#3916,region#3917,city#3918,iata#3919,code#3920,gps#3921] parquet

== Physical Plan ==
TakeOrderedAndProject(limit=5, orderBy=[C_24#3908 DESC NULLS LAST], output=[C_20#3895,C_18#3896,C_21#3897,C_22#3898,C_25#3899,C_19#3900,C_17#3901,C_12#3902,C_15#3903,C_23#3904,C_13#3905,C_16#3906,C_14#3907,C_24#3908])
+- *(1) Project [id#3909 AS C_20#3895, type#3910 AS C_18#3896, name#3911 AS C_21#3897, (round((lat#3912 * 1000.0), 0) / 1000.0) AS C_22#3898, (round((lon#3913 * 1000.0), 0) / 1000.0) AS C_25#3899, (round((elev#3914 * 1000.0), 0) / 1000.0) AS C_19#3900, continent#3915 AS C_17#3901, country#3916 AS C_12#3902, region#3917 AS C_15#3903, city#3918 AS C_23#3904, iata#3919 AS C_13#3905, code#3920 AS C_16#3906, gps#3921 AS C_14#3907, elev#3914 AS C_24#3908]
   +- *(1) Filter (((((isnotnull(lon#3913) AND isnotnull(lat#3912)) AND (lon#3913 <= -104.05)) AND (lon#3913 >= -111.05)) AND (lat#3912 >= 41.0)) AND (lat#3912 <= 45.0))
      +- *(1) ColumnarToRow
         +- FileScan parquet spark_catalog.default.airports[id#3909,type#3910,name#3911,lat#3912,lon#3913,elev#3914,continent#3915,country#3916,region#3917,city#3918,iata#3919,code#3920,gps#3921] Batched: true, DataFilters: [isnotnull(lon#3913), isnotnull(lat#3912), (lon#3913 <= -104.05), (lon#3913 >= -111.05), (lat#391..., Format: Parquet, Location: InMemoryFileIndex(1 paths)[file:/home/acdcadmin/spark-warehouse/airports], PartitionFilters: [], PushedFilters: [IsNotNull(lon), IsNotNull(lat), LessThanOrEqual(lon,-104.05), GreaterThanOrEqual(lon,-111.05), G..., ReadSchema: struct<id:string,type:string,name:string,lat:double,lon:double,elev:double,continent:string,count...

== Parsed Logical Plan ==
'DescribeRelation false, [col_name#3856, data_type#3857, comment#3858]
+- 'UnresolvedTableOrView [default, airports], DESCRIBE TABLE, true

== Analyzed Logical Plan ==
col_name: string, data_type: string, comment: string
DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#3856, data_type#3857, comment#3858]

== Optimized Logical Plan ==
CommandResult [col_name#3856, data_type#3857, comment#3858], Execute DescribeTableCommand, [[id,string,null], [type,string,null], [name,string,null], [lat,double,null], [lon,double,null], [elev,double,null], [continent,string,null], [country,string,null], [region,string,null], [city,string,null], [iata,string,null], [code,string,null], [gps,string,null]]
   +- DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#3856, data_type#3857, comment#3858]

== Physical Plan ==
CommandResult [col_name#3856, data_type#3857, comment#3858]
   +- Execute DescribeTableCommand
         +- DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#3856, data_type#3857, comment#3858]

== Parsed Logical Plan ==
'DescribeRelation false, [col_name#3833, data_type#3834, comment#3835]
+- 'UnresolvedTableOrView [default, airports], DESCRIBE TABLE, true

== Analyzed Logical Plan ==
col_name: string, data_type: string, comment: string
DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#3833, data_type#3834, comment#3835]

== Optimized Logical Plan ==
CommandResult [col_name#3833, data_type#3834, comment#3835], Execute DescribeTableCommand, [[id,string,null], [type,string,null], [name,string,null], [lat,double,null], [lon,double,null], [elev,double,null], [continent,string,null], [country,string,null], [region,string,null], [city,string,null], [iata,string,null], [code,string,null], [gps,string,null]]
   +- DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#3833, data_type#3834, comment#3835]

== Physical Plan ==
CommandResult [col_name#3833, data_type#3834, comment#3835]
   +- Execute DescribeTableCommand
         +- DescribeTableCommand `spark_catalog`.`default`.`airports`, false, [col_name#3833, data_type#3834, comment#3835]

== Parsed Logical Plan ==
SetCommand (-v,None)

== Analyzed Logical Plan ==
key: string, value: string, meaning: string, Since version: string
SetCommand (-v,None)

== Optimized Logical Plan ==
CommandResult [key#3808, value#3809, meaning#3810, Since version#3811], Execute SetCommand, [[spark.sql.adaptive.advisoryPartitionSizeInBytes,<value of spark.sql.adaptive.shuffle.targetPostShuffleInputSize>,The advisory size in bytes of the shuffle partition during adaptive optimization (when spark.sql.adaptive.enabled is true). It takes effect when Spark coalesces small shuffle partitions or splits skewed shuffle partition.,3.0.0], [spark.sql.adaptive.autoBroadcastJoinThreshold,<undefined>,Configures the maximum size in bytes for a table that will be broadcast to all worker nodes when performing a join. By setting this value to -1 broadcasting can be disabled. The default value is same with spark.sql.autoBroadcastJoinThreshold. Note that, this config is used only in adaptive framework.,3.2.0], [spark.sql.adaptive.coalescePartitions.enabled,true,When true and 'spark.sql.adaptive.enabled' is true, Spark will coalesce contiguous shuffle partitions according to the target size (specified by 'spark.sql.adaptive.advisoryPartitionSizeInBytes'), to avoid too many small tasks.,3.0.0], [spark.sql.adaptive.coalescePartitions.initialPartitionNum,<undefined>,The initial number of shuffle partitions before coalescing. If not set, it equals to spark.sql.shuffle.partitions. This configuration only has an effect when 'spark.sql.adaptive.enabled' and 'spark.sql.adaptive.coalescePartitions.enabled' are both true.,3.0.0], [spark.sql.adaptive.coalescePartitions.minPartitionSize,1MB,The minimum size of shuffle partitions after coalescing. This is useful when the adaptively calculated target size is too small during partition coalescing.,3.2.0], [spark.sql.adaptive.coalescePartitions.parallelismFirst,true,When true, Spark does not respect the target size specified by 'spark.sql.adaptive.advisoryPartitionSizeInBytes' (default 64MB) when coalescing contiguous shuffle partitions, but adaptively calculate the target size according to the default parallelism of the Spark cluster. The calculated size is usually smaller than the configured target size. This is to maximize the parallelism and avoid performance regression when enabling adaptive query execution. It's recommended to set this config to false and respect the configured target size.,3.2.0], [spark.sql.adaptive.customCostEvaluatorClass,<undefined>,The custom cost evaluator class to be used for adaptive execution. If not being set, Spark will use its own SimpleCostEvaluator by default.,3.2.0], [spark.sql.adaptive.enabled,true,When true, enable adaptive query execution, which re-optimizes the query plan in the middle of query execution, based on accurate runtime statistics.,1.6.0], [spark.sql.adaptive.forceOptimizeSkewedJoin,false,When true, force enable OptimizeSkewedJoin even if it introduces extra shuffle.,3.3.0], [spark.sql.adaptive.localShuffleReader.enabled,true,When true and 'spark.sql.adaptive.enabled' is true, Spark tries to use local shuffle reader to read the shuffle data when the shuffle partitioning is not needed, for example, after converting sort-merge join to broadcast-hash join.,3.0.0], [spark.sql.adaptive.maxShuffledHashJoinLocalMapThreshold,0b,Configures the maximum size in bytes per partition that can be allowed to build local hash map. If this value is not smaller than spark.sql.adaptive.advisoryPartitionSizeInBytes and all the partition size are not larger than this config, join selection prefer to use shuffled hash join instead of sort merge join regardless of the value of spark.sql.join.preferSortMergeJoin.,3.2.0], [spark.sql.adaptive.optimizeSkewsInRebalancePartitions.enabled,true,When true and 'spark.sql.adaptive.enabled' is true, Spark will optimize the skewed shuffle partitions in RebalancePartitions and split them to smaller ones according to the target size (specified by 'spark.sql.adaptive.advisoryPartitionSizeInBytes'), to avoid data skew.,3.2.0], [spark.sql.adaptive.optimizer.excludedRules,<undefined>,Configures a list of rules to be disabled in the adaptive optimizer, in which the rules are specified by their rule names and separated by comma. The optimizer will log the rules that have indeed been excluded.,3.1.0], [spark.sql.adaptive.rebalancePartitionsSmallPartitionFactor,0.2,A partition will be merged during splitting if its size is small than this factor multiply spark.sql.adaptive.advisoryPartitionSizeInBytes.,3.3.0], [spark.sql.adaptive.skewJoin.enabled,true,When true and 'spark.sql.adaptive.enabled' is true, Spark dynamically handles skew in shuffled join (sort-merge and shuffled hash) by splitting (and replicating if needed) skewed partitions.,3.0.0], [spark.sql.adaptive.skewJoin.skewedPartitionFactor,5.0,A partition is considered as skewed if its size is larger than this factor multiplying the median partition size and also larger than 'spark.sql.adaptive.skewJoin.skewedPartitionThresholdInBytes',3.0.0], [spark.sql.adaptive.skewJoin.skewedPartitionThresholdInBytes,256MB,A partition is considered as skewed if its size in bytes is larger than this threshold and also larger than 'spark.sql.adaptive.skewJoin.skewedPartitionFactor' multiplying the median partition size. Ideally this config should be set larger than 'spark.sql.adaptive.advisoryPartitionSizeInBytes'.,3.0.0], [spark.sql.allowNamedFunctionArguments,true,If true, Spark will turn on support for named parameters for all functions that has it implemented.,3.5.0], [spark.sql.ansi.doubleQuotedIdentifiers,false,When true and 'spark.sql.ansi.enabled' is true, Spark SQL reads literals enclosed in double quoted (") as identifiers. When false they are read as string literals.,3.4.0], [spark.sql.ansi.enabled,false,When true, Spark SQL uses an ANSI compliant dialect instead of being Hive compliant. For example, Spark will throw an exception at runtime instead of returning null results when the inputs to a SQL operator/function are invalid.For full details of this dialect, you can find them in the section "ANSI Compliance" of Spark's documentation. Some ANSI dialect features may be not from the ANSI SQL standard directly, but their behaviors align with ANSI SQL's style,3.0.0], [spark.sql.ansi.enforceReservedKeywords,false,When true and 'spark.sql.ansi.enabled' is true, the Spark SQL parser enforces the ANSI reserved keywords and forbids SQL queries that use reserved keywords as alias names and/or identifiers for table, view, function, etc.,3.3.0], [spark.sql.ansi.relationPrecedence,false,When true and 'spark.sql.ansi.enabled' is true, JOIN takes precedence over comma when combining relation. For example, `t1, t2 JOIN t3` should result to `t1 X (t2 X t3)`. If the config is false, the result is `(t1 X t2) X t3`.,3.4.0], [spark.sql.autoBroadcastJoinThreshold,10MB,Configures the maximum size in bytes for a table that will be broadcast to all worker nodes when performing a join.  By setting this value to -1 broadcasting can be disabled. Note that currently statistics are only supported for Hive Metastore tables where the command `ANALYZE TABLE <tableName> COMPUTE STATISTICS noscan` has been run, and file-based data source tables where the statistics are computed directly on the files of data.,1.1.0], [spark.sql.avro.compression.codec,snappy,Compression codec used in writing of AVRO files. Supported codecs: uncompressed, deflate, snappy, bzip2, xz and zstandard. Default codec is snappy.,2.4.0], ... 183 more fields]
   +- SetCommand (-v,None)

== Physical Plan ==
CommandResult [key#3808, value#3809, meaning#3810, Since version#3811]
   +- Execute SetCommand
         +- SetCommand (-v,None)

== Parsed Logical Plan ==
'ShowTables [namespace#3798, tableName#3799, isTemporary#3800]
+- 'UnresolvedNamespace [global_temp]

== Analyzed Logical Plan ==
namespace: string, tableName: string, isTemporary: boolean
ShowTables [namespace#3798, tableName#3799, isTemporary#3800]
+- ResolvedNamespace V2SessionCatalog(spark_catalog), [global_temp]

== Optimized Logical Plan ==
CommandResult [namespace#3798, tableName#3799, isTemporary#3800], ShowTables [namespace#3798, tableName#3799, isTemporary#3800], V2SessionCatalog(spark_catalog), [global_temp]
   +- ShowTables [namespace#3798, tableName#3799, isTemporary#3800]
      +- ResolvedNamespace V2SessionCatalog(spark_catalog), [global_temp]

== Physical Plan ==
CommandResult <empty>, [namespace#3798, tableName#3799, isTemporary#3800]
   +- ShowTables [namespace#3798, tableName#3799, isTemporary#3800], V2SessionCatalog(spark_catalog), [global_temp]

== Parsed Logical Plan ==
'ShowTables [namespace#3788, tableName#3789, isTemporary#3790]
+- 'UnresolvedNamespace [test]

== Analyzed Logical Plan ==
namespace: string, tableName: string, isTemporary: boolean
ShowTables [namespace#3788, tableName#3789, isTemporary#3790]
+- ResolvedNamespace V2SessionCatalog(spark_catalog), [test]

== Optimized Logical Plan ==
CommandResult [namespace#3788, tableName#3789, isTemporary#3790], ShowTables [namespace#3788, tableName#3789, isTemporary#3790], V2SessionCatalog(spark_catalog), [test]
   +- ShowTables [namespace#3788, tableName#3789, isTemporary#3790]
      +- ResolvedNamespace V2SessionCatalog(spark_catalog), [test]

== Physical Plan ==
CommandResult <empty>, [namespace#3788, tableName#3789, isTemporary#3790]
   +- ShowTables [namespace#3788, tableName#3789, isTemporary#3790], V2SessionCatalog(spark_catalog), [test]

== Parsed Logical Plan ==
'ShowTables [namespace#3768, tableName#3769, isTemporary#3770]
+- 'UnresolvedNamespace [onetableschema]

== Analyzed Logical Plan ==
namespace: string, tableName: string, isTemporary: boolean
ShowTables [namespace#3768, tableName#3769, isTemporary#3770]
+- ResolvedNamespace V2SessionCatalog(spark_catalog), [onetableschema]

== Optimized Logical Plan ==
CommandResult [namespace#3768, tableName#3769, isTemporary#3770], ShowTables [namespace#3768, tableName#3769, isTemporary#3770], V2SessionCatalog(spark_catalog), [onetableschema], [[0,200000000e,300000000c,0,656c626174656e6f,616d65686373,73657079746c6c61,74736574]]
   +- ShowTables [namespace#3768, tableName#3769, isTemporary#3770]
      +- ResolvedNamespace V2SessionCatalog(spark_catalog), [onetableschema]

== Physical Plan ==
CommandResult [namespace#3768, tableName#3769, isTemporary#3770]
   +- ShowTables [namespace#3768, tableName#3769, isTemporary#3770], V2SessionCatalog(spark_catalog), [onetableschema]

== Parsed Logical Plan ==
'ShowTables [namespace#3748, tableName#3749, isTemporary#3750]
+- 'UnresolvedNamespace [default]

== Analyzed Logical Plan ==
namespace: string, tableName: string, isTemporary: boolean
ShowTables [namespace#3748, tableName#3749, isTemporary#3750]
+- ResolvedNamespace V2SessionCatalog(spark_catalog), [default]

== Optimized Logical Plan ==
CommandResult [namespace#3748, tableName#3749, isTemporary#3750], ShowTables [namespace#3748, tableName#3749, isTemporary#3750], V2SessionCatalog(spark_catalog), [default], [[0,2000000007,2800000008,0,746c7561666564,7374726f70726961], [0,2000000007,2800000008,0,746c7561666564,73657079746c6c61], [0,2000000007,2800000009,0,746c7561666564,73657079746c6c61,32], [0,2000000007,280000000d,0,746c7561666564,73657079746c6c61,6369736162], [0,2000000007,280000000e,0,746c7561666564,73657079746c6c61,326369736162], [0,2000000007,2800000009,0,746c7561666564,7079747961727261,65], [0,2000000007,280000000a,0,746c7561666564,7974746e69676962,6570], [0,2000000007,280000000a,0,746c7561666564,79747972616e6962,6570], [0,2000000007,2800000008,0,746c7561666564,6570797465746164], [0,2000000007,280000000b,0,746c7561666564,746c616d69636564,657079], [0,2000000007,2800000009,0,746c7561666564,70797474616f6c66,65], [0,2000000007,2800000008,0,746c7561666564,736570797470616d], [0,2000000007,280000000b,0,746c7561666564,646978617463796e,617461], [0,2000000007,280000000f,0,746c7561666564,746978617463796e,61746164706972], [0,2000000007,2800000010,0,746c7561666564,7365745f656d6f73,32656c6261745f74], [0,2000000007,280000000a,0,746c7561666564,7974746375727473,6570], [0,2000000007,280000000e,0,746c7561666564,656e6f7a69786174,70756b6f6f6c], [0,2000000007,280000000c,0,746c7561666564,74676e696b726f77,73657079], [0,2000000007,2800000016,0,746c7561666564,74676e696b726f77,6874697773657079,7265626d756e]]
   +- ShowTables [namespace#3748, tableName#3749, isTemporary#3750]
      +- ResolvedNamespace V2SessionCatalog(spark_catalog), [default]

== Physical Plan ==
CommandResult [namespace#3748, tableName#3749, isTemporary#3750]
   +- ShowTables [namespace#3748, tableName#3749, isTemporary#3750], V2SessionCatalog(spark_catalog), [default]

== Parsed Logical Plan ==
'ShowTables [namespace#3728, tableName#3729, isTemporary#3730]
+- 'UnresolvedNamespace [c3ba675f1fb64660ba4a90155b35924e]

== Analyzed Logical Plan ==
namespace: string, tableName: string, isTemporary: boolean
ShowTables [namespace#3728, tableName#3729, isTemporary#3730]
+- ResolvedNamespace V2SessionCatalog(spark_catalog), [c3ba675f1fb64660ba4a90155b35924e]

== Optimized Logical Plan ==
CommandResult [namespace#3728, tableName#3729, isTemporary#3730], ShowTables [namespace#3728, tableName#3729, isTemporary#3730], V2SessionCatalog(spark_catalog), [c3ba675f1fb64660ba4a90155b35924e], [[0,2000000020,400000000c,0,6635373661623363,3036363436626631,3531303961346162,6534323935336235,69746e656469796d,72656966]]
   +- ShowTables [namespace#3728, tableName#3729, isTemporary#3730]
      +- ResolvedNamespace V2SessionCatalog(spark_catalog), [c3ba675f1fb64660ba4a90155b35924e]

== Physical Plan ==
CommandResult [namespace#3728, tableName#3729, isTemporary#3730]
   +- ShowTables [namespace#3728, tableName#3729, isTemporary#3730], V2SessionCatalog(spark_catalog), [c3ba675f1fb64660ba4a90155b35924e]