// 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 likeLiteral) {String getLikePattern() {
        return likePattern;
    }

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

    public booleanif isNotLike(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
    public SqlOperator getOperator() {builder.append(String.format(" %s %s", likeType.name(), likePattern));
        return OPERATOR;
    }

    @Override
    public List<SqlNode> getOperandList() { }
        return Collectionsbuilder.emptyListtoString();
    }
}
    @Override
    public void unparse(SqlWriter writer, int leftPrec, int rightPrec) {
        writer.keyword("SHOW CATALOGS");
// SqlShowDatabases
public class SqlShowDatabases extends SqlCall {

    public static final SqlSpecialOperator if (isWithLike()) {OPERATOR =
            ifnew (isNotLike()) {
     SqlSpecialOperator("SHOW DATABASES", SqlKind.OTHER);

    protected final String preposition;
    protected final SqlIdentifier catalogName;
    writer.keyword(String.format("NOT LIKE '%s'", getLikeSqlPattern()))protected final SqlLikeType likeType;
    protected final boolean notLike;
    protected }final elseSqlCharStringLiteral {likeLiteral;

    public SqlShowDatabases(SqlParserPos pos) {
         writer.keyword(String.format("LIKE '%s'", getLikeSqlPattern()))super(pos);
        this.preposition =   }null;
        }
    }
}

// ShowCatalogsOperation 
public class ShowCatalogsOperation implements ShowOperation {
this.catalogName = null;
       private finalthis.likeType boolean= withLikenull;
    private  final boolean this.notLike = false;
    private final String likePattern;

    public ShowCatalogsOperation(boolean notLike, String likePattern) { this.likeLiteral = null;
    }

    public SqlShowDatabases(
   this.withLike = likePattern != null;
     SqlParserPos   this.notLike = notLike;
pos,
           this.likePattern =String likePattern;preposition,
      }

    public boolean isWithLike() {SqlIdentifier catalogName,
        return withLike;
   String }
likeType,
    public boolean isNotLike() {
     boolean notLike,
  return notLike;
    }

    public StringSqlCharStringLiteral getLikePattern(likeLiteral) {
        return likePatternsuper(pos);
    }

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

// SqlShowDatabases
public class SqlShowDatabases extends} SqlCallelse {

        public static final SqlSpecialOperator OPERATORthis.likeType = null;
            new SqlSpecialOperator("SHOW DATABASES", SqlKind.OTHER);
	this.likeLiteral = null;
        }
    // Add IN/FROM and LIKE support
  this.notLike = notLike;
  protected final SqlIdentifier catalogName; }

    protectedpublic finalString String preposition;getPreposition() {
    protected   final booleanreturn notLikepreposition;
    protected final SqlCharStringLiteral likeLiteral;}

    public SqlIdentifier SqlShowDatabasesgetCatalogName(SqlParserPos pos) {
        return super(pos)catalogName;
    }

    public String this.catalogName = null;
() {
        return catalogName != null ? thiscatalogName.prepositiongetSimple() =: null;
    }

    public this.notLike = false;SqlLikeType getLikeType() {
        this.likeLiteral = nullreturn likeType;
    }

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

    public boolean isILike() {
        SqlIdentifierreturn catalogName,
likeType == SqlLikeType.ILIKE;
    }

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

    public boolean isWithLike() {
 SqlCharStringLiteral likeLiteral) {
     return isLike() || superisILike(pos);
    }

    public this.preposition = preposition;SqlCharStringLiteral getLikeLiteral() {
        this.catalogName =return likeLiteral;
    }

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

    @Override
    public SqlOperator getOperator() {
  ? requireNonNull(catalogName, "Catalog name must not be null.")return OPERATOR;
    }

    @Override
    public List<SqlNode> getOperandList() {
         : null;return Objects.isNull(this.catalogName)
        this.notLike = notLike;
      ?  this.likeLiteral = likeLiteral;Collections.emptyList()
    }

    public SqlIdentifier getCatalogName() {
        return catalogName: Collections.singletonList(catalogName);
    }

    public String catalogName() {@Override
    public void unparse(SqlWriter writer, returnint catalogNameleftPrec, != null ? catalogName.getSimple() : null;int rightPrec) {
    }

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

    public boolean isWithLike() {
writer.keyword("SHOW DATABASES");
        } else if (catalogName return Objects.nonNull(likeLiteral);!= null) {
    }

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

    public SqlCharStringLiteral getLikeLiteral() {catalogName.unparse(writer, leftPrec, rightPrec);
        return likeLiteral;}
    }

    public Stringif getLikeSqlPattern(isWithLike()) {
        return Objects.isNull(this.likeLiteral) ? null : likeLiteral.getValueAs(String.class);
if (isNotLike()) {
         }

    @Override
    public SqlOperator getOperator() {writer.keyword(String.format("NOT %s '%s'", likeType.name(), getLikeSqlPattern()));
        return OPERATOR;
    }

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

// ShowDatabasesOperation
public class ShowDatabasesOperation implements ShowOperation {

    private final : Collections.singletonList(catalogName)String preposition;
    }

  private final String catalogName;
  @Override
  private final publicOperationLikeType void unparse(SqlWriter writer, int leftPrec, int rightPrec) {likeType;
    private final boolean notLike;
    private final String likePattern;

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

    if (isWithLike()) {
     /** Use when there is only like. */
    public ShowDatabasesOperation(String  if (isNotLike())likeType, boolean 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  writer.keyword(String.format("LIKE '%s'", getLikeSqlPattern()))not 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.notLike = false;
        this.likePattern = nullcatalogName = checkNotNull(catalogName, "Catalog name must not be null");
    }

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

    public ShowDatabasesOperation(
   this.likePattern = null;
       String preposition, String catalogName, boolean notLike, String likePattern) { }
        this.prepositionnotLike = checkNotNull(preposition, "Preposition must not be null");
        this.catalogName = checkNotNull(catalogName, "Catalog name must not be null");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 (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
// SqlShowConnectors & ShowConnectorsOperation