// 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 SqlShowCatalogsString getLikePattern(SqlParserPos) pos,{
 boolean notLike, SqlCharStringLiteral likeLiteral) {
   return likePattern;
    super(pos);}

    @Override
    this.notLike = notLike;
public String asSummaryString() {
        StringBuilder this.likeLiteralbuilder = likeLiteral new StringBuilder().append("SHOW CATALOGS");
    }

    public boolean isNotLike(if (isWithLike()) {
        return  notLike;
  if (notLike) }{

    public String getLikeSqlPattern() {
        return Objectsbuilder.isNullappend(this.likeLiteral) ? null : likeLiteral.getValueAs(String.classString.format(" NOT %s %s", likeType.name(), likePattern));
    }

    public boolean isWithLike() {
 } else {
     return Objects.nonNull(likeLiteral);
    }

    @Override
  builder.append(String.format(" %s public SqlOperator getOperator%s", likeType.name(), {likePattern));
        return OPERATOR;
    }

    @Override
    public List<SqlNode> getOperandList() {}
        return Collectionsbuilder.emptyListtoString();
    }
}

// SqlShowDatabases
public class SqlShowDatabases extends SqlCall @Override{

    public static final voidSqlSpecialOperator unparse(SqlWriter writer, int leftPrec, int rightPrec) {
OPERATOR =
            new writer.keywordSqlSpecialOperator("SHOW CATALOGSDATABASES", SqlKind.OTHER);

    protected final String preposition;
    protected final SqlIdentifier catalogName;
    protected final if (isWithLike()) {SqlLikeType likeType;
    protected final boolean notLike;
    protected if (isNotLike()) {final SqlCharStringLiteral likeLiteral;

    public SqlShowDatabases(SqlParserPos pos) {
         writer.keyword(String.format("NOT LIKE '%s'", getLikeSqlPattern())super(pos);
        this.preposition = null;
  } else {
      this.catalogName = null;
        writer.keyword(String.format("LIKE '%s'", getLikeSqlPattern()))this.likeType = null;
        this.notLike = false;
  }
      this.likeLiteral = }null;
    }
}

// ShowCatalogsOperation 
public class ShowCatalogsOperation implements ShowOperation {

    public SqlShowDatabases(
          private final booleanSqlParserPos withLike;
pos,
          private final booleanString notLike;preposition,
    private final String likePattern;

    public ShowCatalogsOperation(booleanSqlIdentifier notLikecatalogName,
 String  likePattern) {
        this.withLike = likePattern != null;
String likeType,
           this.notLike =boolean notLike;,
        this.likePattern = likePattern;
  SqlCharStringLiteral likeLiteral) }{

      public boolean isWithLikesuper(pos) {;
        return withLikethis.preposition = preposition;
    }

    public boolean isNotLike() {
this.catalogName =
          return notLike;
    }

 preposition != null
 public String getLikePattern() {
        return likePattern;
    }

    @Override
   ? public String asSummaryString() {
   requireNonNull(catalogName, "Catalog name must not be null.")
     StringBuilder builder = new StringBuilder().append("SHOW CATALOGS");
           if (withLike) {
   : null;
        if (notLikelikeType != null) {
            this.likeType =   builderSqlLikeType.append(String.format(" %s LIKE %s", "NOT", likePattern)of(likeType);
            }this.likeLiteral else {
       = requireNonNull(likeLiteral, "Like pattern must not be null");
         builder.append(String.format(" LIKE %s", likePattern));
} else {
            this.likeType = }null;
        }
    this.likeLiteral    return builder.toString()= null;
    }
}

// SqlShowDatabases
public class SqlShowDatabases extends SqlCall {
 }
    public static final SqlSpecialOperator OPERATORthis.notLike = notLike;
       }

    public newString SqlSpecialOperatorgetPreposition("SHOW DATABASES", SqlKind.OTHER);
	
) {
    // Add IN/FROM and LIKEreturn supportpreposition;
    protected}

 final SqlIdentifier catalogName;
 public SqlIdentifier getCatalogName() protected{
 final String preposition;
    protected finalreturn boolean notLikecatalogName;
    protected final SqlCharStringLiteral likeLiteral;}

    public SqlShowDatabases(SqlParserPos posString catalogName() {
        return catalogName != null ? supercatalogName.getSimple(pos) : null;
    }

    public this.catalogName = null;SqlLikeType getLikeType() {
        this.preposition = nullreturn likeType;
    }

    public this.notLike = false;boolean isLike() {
        this.likeLiteralreturn likeType == nullSqlLikeType.LIKE;
    }

    public SqlShowDatabases(boolean isILike() {
        return likeType   SqlParserPos pos,== SqlLikeType.ILIKE;
    }

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

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

    public SqlCharStringLiteral likeLiteralgetLikeLiteral() {
        super(pos);
        this.preposition = preposition;return likeLiteral;
    }

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

  preposition != null@Override
    public SqlOperator getOperator() {
        return OPERATOR;
    }

    ? requireNonNull(catalogName, "Catalog name must not be null.")
@Override
    public List<SqlNode> getOperandList() {
        return Objects.isNull(this.catalogName)
                : null;? Collections.emptyList()
        this.notLike = notLike;
       : this.likeLiteral = likeLiteralCollections.singletonList(catalogName);
    }

    public@Override
 SqlIdentifier getCatalogName() {
 public void unparse(SqlWriter writer, int leftPrec, int returnrightPrec) catalogName;{
    }

    public Stringif catalogName((this.preposition == null) {
        return catalogName != null ? catalogNamewriter.getSimplekeyword() : null"SHOW DATABASES");
    }

    } publicelse Stringif getPreposition(catalogName != null) {
        return preposition;
    }

    public boolean isWithLike() {
writer.keyword("SHOW DATABASES " + this.preposition);
           return ObjectscatalogName.nonNull(likeLiteralunparse(writer, leftPrec, rightPrec);
        }

       public booleanif isNotLike(isWithLike()) {
        return notLike;
    }

    public SqlCharStringLiteral getLikeLiteralif (isNotLike()) {
        return likeLiteral;
    }

    public Stringwriter.keyword(String.format("NOT %s '%s'", likeType.name(), getLikeSqlPattern() {));
        return Objects.isNull(this.likeLiteral) ? null : likeLiteral.getValueAs(String.class);
    }
} else {
    @Override
    public SqlOperator getOperator() {
     writer.keyword(String.format("%s '%s'",  return OPERATOR;
    }

likeType.name(), getLikeSqlPattern()));
     @Override
    public List<SqlNode> getOperandList() {}
        return Objects.isNull(this.catalogName)}
    }

// ShowDatabasesOperation
public class ShowDatabasesOperation implements ShowOperation {

    private final ? Collections.emptyList()String preposition;
    private final String catalogName;
    private final    : Collections.singletonList(catalogName)OperationLikeType likeType;
    }

private final boolean  @OverridenotLike;
    publicprivate voidfinal unparse(SqlWriter writer, int leftPrec, int rightPrec) {
        if (this.preposition == nullString likePattern;

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

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

    /** Use when  }there is preposition. */
    }
}

//public ShowDatabasesOperation(
public  class ShowDatabasesOperation implements ShowOperation {

    private final String preposition;,
    private final String catalogName;
    private final booleanString withLike;catalogName,
    private final boolean notLike;
    private final String likePattern;likeType,

     public ShowDatabasesOperation() {
     boolean notLike,
  this.preposition = null;
        this.catalogName = null;String likePattern) {
        this.withLikepreposition = false checkNotNull(preposition, "Preposition must not be null");
        this.notLikecatalogName = false;
        this.likePattern = nullcheckNotNull(catalogName, "Catalog name must not be null");
    }

    publicif ShowDatabasesOperation(booleanlikeType notLike, String likePattern!= null) {
            this.prepositionlikeType = nullOperationLikeType.of(likeType);
        this.catalogName = null;
        this.withLikelikePattern = checkNotNull(likePattern, != null;
        this.notLike = notLike"Like pattern must not be null");
        this.likePattern} =else likePattern;{
    }

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

    public String getPreposition() {
        this.withLike = likePattern != nullreturn preposition;
    }

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

    public Stringboolean getPrepositionisLike() {
        return prepositionlikeType == 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 (isWithLike(withLike)) {
            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
// SqlShowConnectors & ShowConnectorsOperation