// Add SqlDescribeCatalog & DescribeCatalogOperation
// Add SqlDescribeDatabase & DescribeDatabaseOperation
// Add SqlDescribeFunction & DescribeFunctionOperation

About DescribeCatalog:

+-------------------------+-----------------------------+

| catalog_description_item|   catalog_description_value |
+-------------------------+-----------------------------+
|            Catalog Name |                       xxx   |
|    

// Add SqlDescribeCatalog & DescribeCatalogOperation
// Add SqlDescribeDatabase & DescribeDatabaseOperation
// Add SqlDescribeFunction & DescribeFunctionOperation

// Changed SqlNodes & Operations

// SqlShowCatalogs 
public class SqlShowCatalogs extends SqlCall {

    public static final SqlSpecialOperator OPERATOR =
            new SqlSpecialOperator("SHOW CATALOGS", SqlKind.OTHER);

    protected final SqlLikeType likeType;
    protected final boolean notLike;
    protected final SqlCharStringLiteral likeLiteral;

    public SqlShowCatalogs(SqlParserPos pos) {
        super(pos);
        this.likeType = null;
        this.notLike = false;
        this.likeLiteral = null;
    }

    public SqlShowCatalogs(
            SqlParserPos pos, String likeType, boolean notLike, SqlCharStringLiteral likeLiteral) {
        super(pos);
        if (likeType != null) {
            this.likeType = SqlLikeType.of(likeType);
            this.likeLiteral = requireNonNull(likeLiteral, "Like pattern must not be null");
        } else {
            this.likeType = null;
Properties| (key1=val1, key2=val2, ...) |
+-------------------------+-----------------------------+


About DescribeDatabase:

+-------------------------+-----------------------------+
|database_description_item|   database_description_value|
+-------------------------+-----------------------------+
|            this.likeLiteral = null;
Database Name|         }
        this.notLike = notLike;
    }employees|

|    public SqlLikeType getLikeType() {
       Description| return likeType;
    }

 For   public boolean isLike() {
    software companies|
|    return likeType == SqlLikeType.LIKE;
    }

    public booleanProperties| isILike() {
        return likeType == SqlLikeType.ILIKE;
    }

    public boolean isWithLike() {
        return isLike() || isILike();
    }

    public boolean isNotLike() {
        return notLike;
    }

    public String getLikeSqlPattern() {
        return Objects.isNull(likeLiteral) ? null : likeLiteral.getValueAs(String.class);
    }

    @Override
    public SqlOperator getOperator() {
        return OPERATOR;
    }

    @Override
    public List<SqlNode> getOperandList() {
        return Collections.emptyList();
    }

    @Override
    public void unparse(SqlWriter writer, int leftPrec, int rightPrec) {
        writer.keyword("SHOW CATALOGS");
(key1=val1, key2=val2, ...) |
+-------------------------+-----------------------------+

About DescribeFunction:

+-------------------------+-----------------------------+
|function_description_item|   function_description_value|
+-------------------------+-----------------------------+
|        Function Name    |                    ABS      |
|        Function Language|                    JAVA     |
|        Resource Uri     |                  file://xxx |
|        ifDetails (isWithLike()) {
        |    if (isNotLike()) {
          details      writer.keyword(String.format("NOT %s '%s'", likeType.name(), getLikeSqlPattern()));
            } else {
                writer.keyword(String.format("%s '%s'", likeType.name(), getLikeSqlPattern()));
            }
        }
    }
}

// ShowCatalogsOperation
public class ShowCatalogsOperation implements ShowOperation {|
+-------------------------+-----------------------------+

The concrete describe infos we can get from the specific catalog object.  

// Changed SqlNodes & Operations

// SqlShowCatalogs 
public class SqlShowCatalogs extends SqlCall {

    public static final SqlSpecialOperator OPERATOR =
            new SqlSpecialOperator("SHOW CATALOGS", SqlKind.OTHER);

    privateprotected final OperationLikeTypeSqlLikeType likeType;
    privateprotected final boolean notLike;
    privateprotected final StringSqlCharStringLiteral likePatternlikeLiteral;

    /** Use when there ispublic no sub-clause. */SqlShowCatalogs(SqlParserPos pos) {
    public    ShowCatalogsOperationsuper(pos) {;
        this.likeType = null;
        this.notLike = false;
        this.likePatternlikeLiteral = null;
    }

    public SqlShowCatalogs(
            SqlParserPos pos, String likeType,  /** Use when there is like. */boolean notLike, SqlCharStringLiteral likeLiteral) {
        super(pos);
    public  ShowCatalogsOperation(String likeType, booleanif notLike, String likePattern(likeType != null) {
            this.likeType = OperationLikeTypeSqlLikeType.of(checkNotNull(likeType,);
 "Like type must not be null"));
        this.likePatternlikeLiteral = checkNotNullrequireNonNull(likePatternlikeLiteral, "Like pattern must not be null");
        this.notLike = notLike;
    }

    public boolean isLike() {
        } else return{
 likeType == OperationLikeType.LIKE;
    }

    public boolean isIlike() {this.likeType = null;
        return likeType    this.likeLiteral == OperationLikeType.ILIKEnull;
    }

    public boolean isWithLike() {}
        return isLike() || isIlike()this.notLike = notLike;
    }

    public booleanSqlLikeType isNotLikegetLikeType() {
        return notLikelikeType;
    }

    public Stringboolean getLikePatternisLike() {
        return likePattern return likeType == SqlLikeType.LIKE;
    }

    @Override
    public Stringboolean asSummaryStringisILike() {
        StringBuilderreturn builderlikeType == new StringBuilder().append("SHOW CATALOGS")SqlLikeType.ILIKE;
    }

    public ifboolean (isWithLike()) {
        return isLike() ||  if isILike(notLike) {;
    }

            builder.append(String.format(" NOT %s %s", likeType.name(), likePattern));public boolean isNotLike() {
        return notLike;
    }

 else   {
public String getLikeSqlPattern() {
        return Objects.isNull(likeLiteral) ? null : builderlikeLiteral.appendgetValueAs(String.format(" %s %s", likeType.name(), likePattern));
class);
    }

    @Override
    public SqlOperator getOperator() {
        return OPERATOR;
    }

    @Override
    public List<SqlNode> getOperandList() }{
        return builderCollections.toStringemptyList();
    }
}

// SqlShowDatabases
public class SqlShowDatabases extends SqlCall {@Override

    public staticvoid final SqlSpecialOperator OPERATOR =
   unparse(SqlWriter writer, int leftPrec, int rightPrec) {
         new SqlSpecialOperatorwriter.keyword("SHOW DATABASES", SqlKind.OTHER);
CATALOGS");
        if (isWithLike()) {
    protected final String preposition;
    protected final SqlIdentifier catalogName;if (isNotLike()) {
    protected final SqlLikeType likeType;
    protected final boolean notLike            writer.keyword(String.format("NOT %s '%s'", likeType.name(), getLikeSqlPattern()));
    protected final SqlCharStringLiteral likeLiteral;

    public SqlShowDatabases(SqlParserPos pos)} else {
        super(pos);
          this.preposition = nullwriter.keyword(String.format("%s '%s'", likeType.name(), getLikeSqlPattern()));
        this.catalogName = null;
  }
      this.likeType = null;}
    }
}

// ShowCatalogsOperation
public class ShowCatalogsOperation this.notLikeimplements =ShowOperation false;{

    private final OperationLikeType likeType;
 this.likeLiteral = null;
 private final boolean }notLike;

    publicprivate SqlShowDatabases(
final String likePattern;

    /** Use when there is no SqlParserPos pos,sub-clause. */
    public ShowCatalogsOperation() {
      String preposition,
 this.likeType = null;
        this.notLike SqlIdentifier= catalogName,false;
        this.likePattern    String likeType,= null;
    }

    /** Use   boolean notLike,
   when there is like. */
    public ShowCatalogsOperation(String likeType, boolean notLike, SqlCharStringLiteralString likeLiterallikePattern) {
        super(pos);
        this.preposition = prepositionthis.likeType = OperationLikeType.of(checkNotNull(likeType, "Like type must not be null"));
        this.catalogNamelikePattern =
 checkNotNull(likePattern, "Like pattern must not be null");
        this.notLike preposition != nullnotLike;
    }

    public boolean isLike() {
        return likeType == OperationLikeType.LIKE;
    ? requireNonNull(catalogName, "Catalog name must not be null.")}

    public boolean isIlike() {
        return likeType == OperationLikeType.ILIKE;
    }

    public boolean    : null;isWithLike() {
        ifreturn isLike(likeType) != null) {|| isIlike();
       }

    public this.likeType = SqlLikeType.of(likeType);boolean isNotLike() {
        return notLike;
   this.likeLiteral = requireNonNull(likeLiteral, "Like pattern must not be null"); }

    public String getLikePattern() {
        }return elselikePattern;
 {
   }

    @Override
    public this.likeType = null;String asSummaryString() {
        StringBuilder builder = new this.likeLiteral = nullStringBuilder().append("SHOW CATALOGS");
        }
  if (isWithLike()) {
      this.notLike = notLike;
    }

    public String getPreposition(if (notLike) {
        return  preposition;
    }

  builder.append(String.format(" NOT public%s SqlIdentifier getCatalogName%s", likeType.name(), {likePattern));
         return catalogName;
  } else }{

    public String catalogName() {
        return catalogName != null ? catalogName.getSimple() : null builder.append(String.format(" %s %s", likeType.name(), likePattern));
    }

     public SqlLikeType getLikeType() {}
        return likeType;}
    }

    public boolean isLikereturn builder.toString() {;
    }
}

// SqlShowDatabases
public   return likeType == SqlLikeType.LIKE;
    }class SqlShowDatabases extends SqlCall {

    public boolean isILike() {static final SqlSpecialOperator OPERATOR =
        return likeType == SqlLikeType.ILIKE;
 new SqlSpecialOperator("SHOW  }DATABASES", SqlKind.OTHER);

    publicprotected booleanfinal isNotLike() {String preposition;
    protected final SqlIdentifier  return notLikecatalogName;
    }

protected final   public boolean isWithLike() {SqlLikeType likeType;
        return isLike() || isILike()protected final boolean notLike;
    protected final SqlCharStringLiteral }likeLiteral;

    public SqlCharStringLiteral getLikeLiteral(SqlShowDatabases(SqlParserPos pos) {
        return likeLiteralsuper(pos);
    }

    publicthis.preposition String getLikeSqlPattern() {= null;
        return Objects.isNull(likeLiteral) ? null : likeLiteral.getValueAs(String.class);
this.catalogName = null;
      }

  this.likeType = @Overridenull;
      public  SqlOperator getOperator() {this.notLike = false;
        this.likeLiteral return= OPERATORnull;
    }

    @Overridepublic SqlShowDatabases(
    public List<SqlNode> getOperandList() {
     SqlParserPos   return Objects.isNull(this.catalogName)
pos,
            String preposition,
    ? Collections.emptyList()
       SqlIdentifier catalogName,
        : Collections.singletonList(catalogName);
   String }likeType,

    @Override
    public void unparse(SqlWriter writer, intboolean leftPrecnotLike,
 int rightPrec) {
        if (this.preposition == nullSqlCharStringLiteral likeLiteral) {
        super(pos);
      writer.keyword("SHOW DATABASES")  this.preposition = preposition;
        } else if (this.catalogName !=
 null) {
            writer.keyword("SHOW DATABASES "preposition + this.preposition);!= null
            catalogName.unparse(writer, leftPrec, rightPrec);
        }
   ? requireNonNull(catalogName, "Catalog name must not if (isWithLike()) {
be null.")
             if (isNotLike()) {
         : null;
      writer.keyword(String.format("NOT %s '%s'",if likeType.name(), getLikeSqlPattern()));(likeType != null) {
            this.likeType = SqlLikeType.of(likeType);
  } else {
        this.likeLiteral = requireNonNull(likeLiteral, "Like pattern must not  writer.keyword(String.format("%s '%s'", likeType.name(), getLikeSqlPattern()))be null");
        } else   }{
        }
    }

// ShowDatabasesOperation
public class ShowDatabasesOperation implements ShowOperation {

this.likeType = null;
    private final String preposition;
    private finalthis.likeLiteral String= catalogNamenull;
    private  final boolean withLike;}
    private final boolean    this.notLike = notLike;
    private final String likePattern;}

    public ShowDatabasesOperationString getPreposition() {
        this.preposition = null;return preposition;
    }

    public SqlIdentifier getCatalogName() {
 this.catalogName = null;
     return catalogName;
  this.withLike = false;
    }

    public String catalogName() {
    this.notLike = false;
  return catalogName != null ?  this.likePattern =catalogName.getSimple() : null;
    }

    public SqlLikeType ShowDatabasesOperation(boolean notLike, String likePatterngetLikeType() {
        this.preposition = nullreturn likeType;
    }

    public this.catalogName = null;boolean isLike() {
        this.withLikereturn likeType = likePattern != nullSqlLikeType.LIKE;
    }

    this.notLike = notLike;public boolean isILike() {
        this.likePattern return likeType == likePatternSqlLikeType.ILIKE;
    }

    public ShowDatabasesOperation(boolean isNotLike() {
        return notLike;
   String preposition,}

 String catalogName, boolean notLike,public Stringboolean likePatternisWithLike() {
        this.preposition = checkNotNull(preposition, "Preposition must not be null"return isLike() || isILike();
        this.catalogName = checkNotNull(catalogName, "Catalog name must not be null");}

    public SqlCharStringLiteral getLikeLiteral() {
        this.withLike = likePattern != null;return likeLiteral;
    }

    public String getLikeSqlPattern() {
 this.notLike = notLike;
     return Objects.isNull(likeLiteral) ? this.likePatternnull = likePattern: likeLiteral.getValueAs(String.class);
    }

    @Override
    public StringSqlOperator getPrepositiongetOperator() {
        return prepositionOPERATOR;
    }

    @Override
    public StringList<SqlNode> getCatalogNamegetOperandList() {
        return catalogName;Objects.isNull(this.catalogName)
    }

    public boolean isWithLike() {
        return withLike;
    }

? Collections.emptyList()
     public boolean isNotLike() {
        return notLike: Collections.singletonList(catalogName);
    }

    public String getLikePattern() {@Override
    public void unparse(SqlWriter writer, return likePattern;
    }
int leftPrec, int rightPrec) {
    @Override
    if public String asSummaryString((this.preposition == null) {
        StringBuilder builder = new StringBuilder()writer.appendkeyword("SHOW DATABASES");
        } else if (prepositioncatalogName != null) {
            builder.append(String.formatwriter.keyword("SHOW %sDATABASES %s", preposition, catalogName))" + this.preposition);
            catalogName.unparse(writer, leftPrec, rightPrec);
        }
        if (withLikeisWithLike()) {
            if (isNotLike(notLike)) {
                builderwriter.appendkeyword(String.format("NOT %s LIKE '%s'", "NOT"likeType.name(), likePatterngetLikeSqlPattern()));
            } else {
                builderwriter.appendkeyword(String.format("%s LIKE '%s'", likePatternlikeType.name(), getLikeSqlPattern()));
            }
        }
        return builder.toString();
    }
}
// ShowDatabasesOperation
public class ShowDatabasesOperation implements ShowOperation {

    private final String preposition;
    private final String catalogName;
    private final OperationLikeType likeType;
    private final boolean notLike;
    private final String likePattern;

    /** Use when there is no sub-clause. */
    public ShowDatabasesOperation() {
        this.preposition = null;
        this.catalogName = null;
        this.likeType = null;
        this.notLike = false;
        this.likePattern = null;
    }

    /** Use when there is only like. */
    public ShowDatabasesOperation(String likeType, boolean notLike, String likePattern) {
        this.preposition = null;
        this.catalogName = null;
        this.likeType = OperationLikeType.of(checkNotNull(likeType, "Like type must not be null"));
        this.likePattern = checkNotNull(likePattern, "Like pattern must not be null");
        this.notLike = notLike;
    }

    /** Use when there is preposition and like. */
    public ShowDatabasesOperation(
            String preposition,
            String catalogName,
            String likeType,
            boolean notLike,
            String likePattern) {
        this.preposition = checkNotNull(preposition, "Preposition must not be null");
        this.catalogName = checkNotNull(catalogName, "Catalog name must not be null");
        if (likeType != null) {
            this.likeType = OperationLikeType.of(likeType);
            this.likePattern = checkNotNull(likePattern, "Like pattern must not be null");
        } else {
            this.likeType = null;
            this.likePattern = null;
        }
        this.notLike = notLike;
    }

    public String getPreposition() {
        return preposition;
    }

    public String getCatalogName() {
        return catalogName;
    }

    public boolean isLike() {
        return likeType == OperationLikeType.LIKE;
    }

    public boolean isIlike() {
        return likeType == OperationLikeType.ILIKE;
    }

    public boolean isWithLike() {
        return isLike() || isIlike();
    }

    public boolean isNotLike() {
        return notLike;
    }

    public String getLikePattern() {
        return likePattern;
    }

    @Override
    public String asSummaryString() {
        StringBuilder builder = new StringBuilder().append("SHOW DATABASES");
        if (preposition != null) {
            builder.append(String.format(" %s %s", preposition, catalogName));
        }
        if (isWithLike()) {
            if (notLike) {
                builder.append(String.format(" NOT %s %s", likeType.name(), likePattern));
            } else {
                builder.append(String.format(" %s %s", likeType.name(), likePattern));
            }
        }
        return builder.toString();
    }
}

// omit here. basically same as ShowCatalogs/ShowDatabases above.
// SqlShowFunctions & ShowFunctionsOperation
// SqlShowViews & ShowViewsOperation
// SqlShowModules & ShowModulesOperation
// SqlShowJars & ShowJarsOperation
// SqlShowJobs & ShowJobsOperation