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

About DescribeCatalog:

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

| catalog_description_item|   catalog_description_value |
+-------------------------+-----------------------------+
|            Catalog Name |                       xxx   |
|               Properties| (key1=val1, key2=val2, ...) |
+-------------------------+-----------------------------+


About DescribeDatabase:

+-------------------------+-----------------------------+
|database_description_item|   database_description_value|
+-------------------------+-----------------------------+
|            Database Name|                    employees|
|              Description|       For software companies|
|               Properties| (key1=val1, key2=val2, ...) |
+-------------------------+-----------------------------+

About DescribeFunction:

+-------------------------+-----------------------------+
|function_description_item|   function_description_value|
+-------------------------+-----------------------------+
|        Function Name    |                    ABS      |
|        Function Language|                    JAVA     |
|        Resource Uri     |                  file://xxx |
|        Details          |                details      |
+-------------------------+-----------------------------+

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);

    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;
            this.likeLiteral = null;
        }
        this.notLike = notLike;
    }

    public SqlLikeType getLikeType() {
        return likeType;
    }

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

    public boolean 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");
        if (isWithLike()) {
            if (isNotLike()) {
                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 {

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

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

    /** Use when there is like. */
    public ShowCatalogsOperation(String likeType, boolean notLike, String likePattern) {
        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;
    }

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

// 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);
    // Add LIKE support
    protected final boolean notLike;
    protected final SqlCharStringLiteral likeLiteral;

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

    public SqlShowCatalogs(SqlParserPos pos, boolean notLike, SqlCharStringLiteral likeLiteralisIlike() {
        return likeType  super(pos)== OperationLikeType.ILIKE;
    }

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

    public boolean isNotLike() {
        return notLike;
    }

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

    }@Override

    public booleanString isWithLikeasSummaryString() {
        StringBuilder builder = returnnew ObjectsStringBuilder().nonNull(likeLiteralappend("SHOW CATALOGS");
    }

    @Override
    public SqlOperator getOperatorif (isWithLike()) {
        return  OPERATOR;
  if (notLike) }{

    @Override
    public List<SqlNode> getOperandList() {
     builder.append(String.format(" NOT %s return%s", CollectionslikeType.emptyListname(), likePattern));
     }

     @Override
  } else public{
 void unparse(SqlWriter writer, int leftPrec, int rightPrec) {
        writerbuilder.keyword("SHOW CATALOGS");
        if (isWithLike()) {append(String.format(" %s %s", likeType.name(), likePattern));
            if (isNotLike()) {
}
        }
        return writerbuilder.keyword(String.format("NOT LIKE '%s'", getLikeSqlPattern()))toString();
    }
}

// SqlShowDatabases
public class SqlShowDatabases extends SqlCall {

    }public elsestatic {
final SqlSpecialOperator OPERATOR =
            new writer.keyword(String.format("LIKE '%s'SqlSpecialOperator("SHOW DATABASES", getLikeSqlPattern()));
            }SqlKind.OTHER);

    protected final String  }preposition;
    }
}

// ShowCatalogsOperation 
public class ShowCatalogsOperation implements ShowOperation {protected final SqlIdentifier catalogName;
    privateprotected final booleanSqlLikeType withLikelikeType;
    privateprotected final boolean notLike;
    privateprotected final StringSqlCharStringLiteral likePatternlikeLiteral;

    public ShowCatalogsOperationSqlShowDatabases(boolean notLike, String likePatternSqlParserPos pos) {
        this.withLike = likePattern != nullsuper(pos);
        this.notLikepreposition = notLikenull;
        this.likePatterncatalogName = likePatternnull;
    }

    publicthis.likeType boolean isWithLike() {
        return withLike= null;
    }

    publicthis.notLike boolean isNotLike() {
= false;
        this.likeLiteral return= notLikenull;
    }

    public String getLikePattern() {SqlShowDatabases(
        return likePattern;
   SqlParserPos }

pos,
       @Override
    public String asSummaryString() {preposition,
        StringBuilder builder = new StringBuilder().append("SHOW CATALOGS"); SqlIdentifier catalogName,
        if (withLike) {    String likeType,
            ifboolean (notLike),
 {
           SqlCharStringLiteral likeLiteral) {
   builder.append(String.format(" %s LIKE %s", "NOT", likePattern)) super(pos);
        this.preposition    } else {= preposition;
        this.catalogName =
       builder.append(String.format(" LIKE %s", likePattern));
      preposition != null
    }
        }
        return builder.toString();
    }
}

// SqlShowDatabases
public class SqlShowDatabases extends SqlCall {

? requireNonNull(catalogName, "Catalog name must not be null.")
     public static final SqlSpecialOperator OPERATOR =
            new SqlSpecialOperator("SHOW DATABASES", SqlKind.OTHER);
	
 : null;
       // Add IN/FROM and LIKE supportif (likeType != null) {
    protected final SqlIdentifier catalogName;
    protected finalthis.likeType String preposition= SqlLikeType.of(likeType);
    protected final boolean notLike;
    protected finalthis.likeLiteral SqlCharStringLiteral= requireNonNull(likeLiteral;

, "Like pattern must publicnot SqlShowDatabases(SqlParserPos pos) {
be null");
        } else super(pos);{
            this.catalogNamelikeType = null;
            this.prepositionlikeLiteral = null;
        this.notLike = false;}
        this.likeLiteralnotLike = nullnotLike;
    }

    public String SqlShowDatabasesgetPreposition() {
        return preposition;
    }

    public SqlIdentifier SqlParserPos pos,
getCatalogName() {
        return catalogName;
    }

    public SqlIdentifierString catalogName,() {
        return catalogName != null String preposition,
  ? catalogName.getSimple() : null;
    }

    public SqlLikeType boolean notLike,getLikeType() {
        return likeType;
   SqlCharStringLiteral likeLiteral) { }

    public boolean   superisLike(pos); {
        this.preposition return likeType == prepositionSqlLikeType.LIKE;
    }

    this.catalogName =
  public boolean isILike() {
        return likeType == SqlLikeType.ILIKE;
   preposition != null }

    public boolean isNotLike() {
        return notLike;
    }

    public ?boolean requireNonNullisWithLike(catalogName, "Catalog name must not be null.")
) {
        return isLike() || isILike();
    }

    public SqlCharStringLiteral getLikeLiteral() {
        :return nulllikeLiteral;
    }

    public this.notLike = notLike;String getLikeSqlPattern() {
        thisreturn Objects.isNull(likeLiteral) ? null =: likeLiteral.getValueAs(String.class);
    }

    @Override
    public SqlIdentifierSqlOperator getCatalogNamegetOperator() {
        return catalogNameOPERATOR;
    }

    @Override
    public StringList<SqlNode> catalogNamegetOperandList() {
        return Objects.isNull(this.catalogName != null ? catalogName.getSimple() : null;
)
                 }

? Collections.emptyList()
     public String getPreposition() {
        return preposition: Collections.singletonList(catalogName);
    }

    @Override
    public booleanvoid isWithLike(unparse(SqlWriter writer, int leftPrec, int rightPrec) {
        returnif Objects.nonNull(likeLiteral);
    }

(this.preposition == null) {
     public boolean isNotLike() {
    writer.keyword("SHOW DATABASES");
   return notLike;
    }

 else if (catalogName public SqlCharStringLiteral getLikeLiteral(!= null) {
        return likeLiteral;
    }

    public String getLikeSqlPattern() {
writer.keyword("SHOW DATABASES " + this.preposition);
           return ObjectscatalogName.isNull(this.likeLiteral) ? null : likeLiteral.getValueAs(String.class);
unparse(writer, leftPrec, rightPrec);
        }

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

    @Override
    public List<SqlNode> getOperandList() {
     writer.keyword(String.format("NOT %s  return Objects.isNull(this.catalogName)'%s'", likeType.name(), getLikeSqlPattern()));
            } else   ? Collections.emptyList()
{
                 : Collections.singletonList(catalogName);
writer.keyword(String.format("%s '%s'", likeType.name(), getLikeSqlPattern()));
       }

     @Override}
    public  void unparse(SqlWriter writer, int leftPrec, int rightPrec) {
        if (this.preposition == null) {
            writer.keyword("SHOW DATABASES") }
    }

// ShowDatabasesOperation
public class ShowDatabasesOperation implements ShowOperation {

    private final String preposition;
    private final String catalogName;
    private final OperationLikeType likeType;
    private final boolean notLike;
 } else if (catalogNameprivate !=final null) {String likePattern;

    /** Use when there is no sub-clause.  writer.keyword("SHOW DATABASES " + this.preposition);
  */
    public ShowDatabasesOperation() {
          catalogName.unparse(writer, leftPrec, rightPrec)this.preposition = null;
        this.catalogName = }null;
        if (isWithLike()) {this.likeType = null;
        this.notLike = false;
  if (isNotLike()) {
    this.likePattern = null;
    }

      writer.keyword(String.format("NOT LIKE '%s'", getLikeSqlPattern()));
   /** Use when there is only like. */
    public ShowDatabasesOperation(String likeType, boolean notLike, }String elselikePattern) {
        this.preposition = null;
        writer.keyword(String.format("LIKE '%s'", getLikeSqlPattern()))this.catalogName = null;
        this.likeType    }
        }= OperationLikeType.of(checkNotNull(likeType, "Like type must not be null"));
    }
}

// ShowDatabasesOperation
public class ShowDatabasesOperation implementsthis.likePattern ShowOperation {

    private final String preposition= checkNotNull(likePattern, "Like pattern must not be null");
    private final String catalogName;
 this.notLike   private final boolean withLike= notLike;
    private}

 final boolean notLike;
 /** Use when privatethere finalis String likePattern;

preposition. */
    public ShowDatabasesOperation()
   {
        this.preposition =String null;preposition,
        this.catalogName = null;
  String catalogName,
     this.withLike = false;
     String likeType,
  this.notLike = false;
        this.likePattern = null;
boolean notLike,
     }

    public ShowDatabasesOperation(boolean notLike, String likePattern) {
        this.preposition = checkNotNull(preposition, "Preposition must not be null");
        this.catalogName = checkNotNull(catalogName, "Catalog name must not be null");
        this.withLike = likePattern != null if (likeType != null) {
            this.likeType = OperationLikeType.of(likeType);
        this.notLike = notLike;
  this.likePattern = checkNotNull(likePattern, "Like pattern must this.likePatternnot =be likePatternnull");
     }

   } publicelse ShowDatabasesOperation({
            String preposition, String catalogName, boolean notLike, String likePattern) {
this.likeType = null;
              this.prepositionlikePattern = checkNotNull(preposition, "Preposition must not be null");null;
        }
        this.catalogNamenotLike = checkNotNull(catalogName, "Catalog name must not be null");
    notLike;
    }

    public String getPreposition() {
     this.withLike = likePattern !=return nullpreposition;
    }

    public this.notLike = notLike;String getCatalogName() {
        this.likePattern = likePatternreturn catalogName;
    }

    public Stringboolean getPrepositionisLike() {
        return likeType return preposition== OperationLikeType.LIKE;
    }

    public Stringboolean getCatalogNameisIlike() {
        return catalogName likeType == OperationLikeType.ILIKE;
    }

    public boolean isWithLike() {
        return withLike 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 (withLikeisWithLike()) {
            if (notLike) {
                builder.append(String.format(" NOT %s LIKE %s", "NOT"likeType.name(), likePattern));
            } else {
                builder.append(String.format(" LIKE%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