override def allProceduresAreCallable()

in linkis-computation-governance/linkis-jdbc-driver/src/main/scala/org/apache/linkis/ujes/jdbc/UJESSQLDatabaseMetaData.scala [35:427]
272 lines of code
11 McCabe index (conditional complexity)

  override def allProceduresAreCallable(): Boolean = false

  override def allTablesAreSelectable(): Boolean = false

  override def getURL: String = ujesSQLConnection.getProps.getProperty("URL")

  override def getUserName: String =
    if (ujesSQLConnection.getProps.containsKey("user"))
      ujesSQLConnection.getProps.getProperty("user")
    else
      throw new LinkisSQLException(LinkisSQLErrorCode.PARAMS_NOT_FOUND, "Missing user information")

  override def isReadOnly: Boolean = false

  override def nullsAreSortedHigh(): Boolean = false

  override def nullsAreSortedLow(): Boolean = false

  override def nullsAreSortedAtStart(): Boolean = false

  override def nullsAreSortedAtEnd(): Boolean = false

  override def getDatabaseProductName: String = "linkis"

  override def getDatabaseProductVersion: String = ""

  override def getDriverName: String = "Linkis JDBC Driver"

  override def getDriverVersion: String = UJESSQLDriverMain.DEFAULT_VERSION.toString

  override def getDriverMajorVersion: Int = UJESSQLDriverMain.DEFAULT_VERSION

  override def getDriverMinorVersion: Int = UJESSQLDriverMain.DEFAULT_VERSION

  override def usesLocalFiles(): Boolean = false

  override def usesLocalFilePerTable(): Boolean = false

  override def supportsMixedCaseIdentifiers(): Boolean = false

  override def storesUpperCaseIdentifiers(): Boolean = false

  override def storesLowerCaseIdentifiers(): Boolean = false

  override def storesMixedCaseIdentifiers(): Boolean = false

  override def supportsMixedCaseQuotedIdentifiers(): Boolean = false

  override def storesUpperCaseQuotedIdentifiers(): Boolean = false

  override def storesLowerCaseQuotedIdentifiers(): Boolean = false

  override def storesMixedCaseQuotedIdentifiers(): Boolean = false

  override def getIdentifierQuoteString: String = " "

  override def getSQLKeywords: String =
    throw new LinkisSQLException(
      LinkisSQLErrorCode.NOSUPPORT_METADATA,
      "getSQLKeywords not supported"
    )

  override def getNumericFunctions: String = ""

  override def getStringFunctions: String = ""

  override def getSystemFunctions: String = ""

  override def getTimeDateFunctions: String = ""

  override def getSearchStringEscape: String = "\\"

  override def getExtraNameCharacters: String = ""

  override def supportsAlterTableWithAddColumn(): Boolean = true

  override def supportsAlterTableWithDropColumn(): Boolean = false

  override def supportsColumnAliasing(): Boolean = true

  override def nullPlusNonNullIsNull(): Boolean = false

  override def supportsConvert(): Boolean = false

  override def supportsConvert(fromType: Int, toType: Int): Boolean = false

  override def supportsTableCorrelationNames(): Boolean = false

  override def supportsDifferentTableCorrelationNames(): Boolean = false

  override def supportsExpressionsInOrderBy(): Boolean = false

  override def supportsOrderByUnrelated(): Boolean = false

  override def supportsGroupBy(): Boolean = true

  override def supportsGroupByUnrelated(): Boolean = false

  override def supportsGroupByBeyondSelect(): Boolean = false

  override def supportsLikeEscapeClause(): Boolean = false

  override def supportsMultipleResultSets(): Boolean = false

  override def supportsMultipleTransactions(): Boolean = false

  override def supportsNonNullableColumns(): Boolean = false

  override def supportsMinimumSQLGrammar(): Boolean = false

  override def supportsCoreSQLGrammar(): Boolean = false

  override def supportsExtendedSQLGrammar(): Boolean = false

  override def supportsANSI92EntryLevelSQL(): Boolean = false

  override def supportsANSI92IntermediateSQL(): Boolean = false

  override def supportsANSI92FullSQL(): Boolean = false

  override def supportsIntegrityEnhancementFacility(): Boolean = false

  override def supportsOuterJoins(): Boolean = true

  override def supportsFullOuterJoins(): Boolean = true

  override def supportsLimitedOuterJoins(): Boolean = true

  override def getSchemaTerm: String = "database"

  override def getProcedureTerm: String = new String("UDF")

  override def getCatalogTerm: String = "instance"

  override def isCatalogAtStart: Boolean = throw new LinkisSQLException(
    LinkisSQLErrorCode.NOSUPPORT_METADATA,
    "isCatalogAtStart not supported"
  )

  override def getCatalogSeparator: String = "."

  override def supportsSchemasInDataManipulation(): Boolean = true

  override def supportsSchemasInProcedureCalls(): Boolean = false

  override def supportsSchemasInTableDefinitions(): Boolean = true

  override def supportsSchemasInIndexDefinitions(): Boolean = false

  override def supportsSchemasInPrivilegeDefinitions(): Boolean = false

  override def supportsCatalogsInDataManipulation(): Boolean = false

  override def supportsCatalogsInProcedureCalls(): Boolean = false

  override def supportsCatalogsInTableDefinitions(): Boolean = false

  override def supportsCatalogsInIndexDefinitions(): Boolean = false

  override def supportsCatalogsInPrivilegeDefinitions(): Boolean = false

  override def supportsPositionedDelete(): Boolean = false

  override def supportsPositionedUpdate(): Boolean = false

  override def supportsSelectForUpdate(): Boolean = false

  override def supportsStoredProcedures(): Boolean = false

  override def supportsSubqueriesInComparisons(): Boolean = false

  override def supportsSubqueriesInExists(): Boolean = false

  override def supportsSubqueriesInIns(): Boolean = false

  override def supportsSubqueriesInQuantifieds(): Boolean = false

  override def supportsCorrelatedSubqueries(): Boolean = false

  override def supportsUnion(): Boolean = false

  override def supportsUnionAll(): Boolean = true

  override def supportsOpenCursorsAcrossCommit(): Boolean = false

  override def supportsOpenCursorsAcrossRollback(): Boolean = false

  override def supportsOpenStatementsAcrossCommit(): Boolean = false

  override def supportsOpenStatementsAcrossRollback(): Boolean = false

  override def getMaxBinaryLiteralLength: Int = throw new LinkisSQLException(
    LinkisSQLErrorCode.NOSUPPORT_METADATA,
    "getMaxBinaryLiteralLength not supported"
  )

  override def getMaxCharLiteralLength: Int = throw new LinkisSQLException(
    LinkisSQLErrorCode.NOSUPPORT_METADATA,
    "getMaxCharLiteralLength not supported"
  )

  override def getMaxColumnNameLength: Int = 128

  override def getMaxColumnsInGroupBy: Int = throw new LinkisSQLException(
    LinkisSQLErrorCode.NOSUPPORT_METADATA,
    "getMaxColumnsInGroupBy not supported"
  )

  override def getMaxColumnsInIndex: Int = throw new LinkisSQLException(
    LinkisSQLErrorCode.NOSUPPORT_METADATA,
    "getMaxColumnsInIndex not supported"
  )

  override def getMaxColumnsInOrderBy: Int = throw new LinkisSQLException(
    LinkisSQLErrorCode.NOSUPPORT_METADATA,
    "getMaxColumnsInOrderBy not supported"
  )

  override def getMaxColumnsInSelect: Int = throw new LinkisSQLException(
    LinkisSQLErrorCode.NOSUPPORT_METADATA,
    "getMaxColumnsInSelect not supported"
  )

  override def getMaxColumnsInTable: Int = throw new LinkisSQLException(
    LinkisSQLErrorCode.NOSUPPORT_METADATA,
    "getMaxColumnsInTable not supported"
  )

  override def getMaxConnections: Int = throw new LinkisSQLException(
    LinkisSQLErrorCode.NOSUPPORT_METADATA,
    "getMaxConnections not supported"
  )

  override def getMaxCursorNameLength: Int = throw new LinkisSQLException(
    LinkisSQLErrorCode.NOSUPPORT_METADATA,
    "getMaxCursorNameLength not supported"
  )

  override def getMaxIndexLength: Int = throw new LinkisSQLException(
    LinkisSQLErrorCode.NOSUPPORT_METADATA,
    "getMaxIndexLength not supported"
  )

  override def getMaxSchemaNameLength: Int = throw new LinkisSQLException(
    LinkisSQLErrorCode.NOSUPPORT_METADATA,
    "getMaxSchemaNameLength not supported"
  )

  override def getMaxProcedureNameLength: Int = throw new LinkisSQLException(
    LinkisSQLErrorCode.NOSUPPORT_METADATA,
    "getMaxProcedureNameLength not supported"
  )

  override def getMaxCatalogNameLength: Int = throw new LinkisSQLException(
    LinkisSQLErrorCode.NOSUPPORT_METADATA,
    "getMaxCatalogNameLength not supported"
  )

  override def getMaxRowSize: Int =
    throw new LinkisSQLException(
      LinkisSQLErrorCode.NOSUPPORT_METADATA,
      "getMaxRowSize not supported"
    )

  override def doesMaxRowSizeIncludeBlobs(): Boolean = throw new LinkisSQLException(
    LinkisSQLErrorCode.NOSUPPORT_METADATA,
    "doesMaxRowSizeIncludeBlobs not supported"
  )

  override def getMaxStatementLength: Int = throw new LinkisSQLException(
    LinkisSQLErrorCode.NOSUPPORT_METADATA,
    "getMaxStatementLength not supported"
  )

  override def getMaxStatements: Int = throw new LinkisSQLException(
    LinkisSQLErrorCode.NOSUPPORT_METADATA,
    "getMaxStatements not supported"
  )

  override def getMaxTableNameLength: Int = throw new LinkisSQLException(
    LinkisSQLErrorCode.NOSUPPORT_METADATA,
    "getMaxTableNameLength not supported"
  )

  override def getMaxTablesInSelect: Int = throw new LinkisSQLException(
    LinkisSQLErrorCode.NOSUPPORT_METADATA,
    "getMaxTablesInSelect not supported"
  )

  override def getMaxUserNameLength: Int = throw new LinkisSQLException(
    LinkisSQLErrorCode.NOSUPPORT_METADATA,
    "getMaxUserNameLength not supported"
  )

  override def getDefaultTransactionIsolation: Int = 0

  override def supportsTransactions(): Boolean = false

  override def supportsTransactionIsolationLevel(level: Int): Boolean = false

  override def supportsDataDefinitionAndDataManipulationTransactions(): Boolean = false

  override def supportsDataManipulationTransactionsOnly(): Boolean = false

  override def dataDefinitionCausesTransactionCommit(): Boolean = throw new LinkisSQLException(
    LinkisSQLErrorCode.NOSUPPORT_METADATA,
    "dataDefinitionCausesTransactionCommit not supported"
  )

  override def dataDefinitionIgnoredInTransactions(): Boolean = throw new LinkisSQLException(
    LinkisSQLErrorCode.NOSUPPORT_METADATA,
    "dataDefinitionIgnoredInTransactions not supported"
  )

  override def getProcedures(
      catalog: String,
      schemaPattern: String,
      procedureNamePattern: String
  ): ResultSet = null

  override def getProcedureColumns(
      catalog: String,
      schemaPattern: String,
      procedureNamePattern: String,
      columnNamePattern: String
  ): ResultSet = null

  override def getTables(
      catalog: String,
      schemaPattern: String,
      tableNamePattern: String,
      types: Array[String]
  ): ResultSet = {
    val resultCatalog = if (StringUtils.isNotBlank(schemaPattern)) {
      schemaPattern
    } else if (StringUtils.isNotBlank(catalog)) {
      catalog
    } else {
      s"${getUserName}_ind"
    }
    logger.info(s"resultCatalog is ${resultCatalog}")
    val getTableAction =
      GetTablesAction.builder().setUser(getUserName).setDatabase(resultCatalog).build()
    val result = ujesSQLConnection.ujesClient.getTables(getTableAction)
    val tables = result.getTables
    val resultTables = new util.ArrayList[util.Map[String, String]]()
    tables.foreach { table =>
      val tableType =
        if (table.get("isView").asInstanceOf[Boolean]) TableType.VIEW.name()
        else TableType.TABLE.name()
      val resultTable = new util.HashMap[String, String]()
      val tableName = table.get("tableName").asInstanceOf[String]
      resultTable.put("catalog", resultCatalog)
      resultTable.put("tableName", tableName)
      resultTable.put("tableType", tableType)
      if (null == types || types.contains(tableType)) {
        if (
            StringUtils.isNotBlank(tableNamePattern) && tableNamePattern.equalsIgnoreCase(tableName)
        ) {
          resultTables.add(resultTable)
        } else if (StringUtils.isBlank(tableNamePattern)) {
          resultTables.add(resultTable)
        }
      }
    }
    val resultSet: LinkisMetaDataResultSet[util.Map[String, String]] =
      new LinkisMetaDataResultSet[util.Map[String, String]](
        util.Arrays.asList("TABLE_CAT", "TABLE_SCHEM", "TABLE_NAME", "TABLE_TYPE", "REMARKS"),
        util.Arrays.asList("string", "string", "string", "string", "string"),
        resultTables
      ) {
        private var cnt = 0

        override def next(): Boolean = {
          if (cnt < data.size()) {
            val resultTable = new util.ArrayList[Object](5)
            val table = data.get(cnt)
            resultTable.add(table.get("catalog"))
            resultTable.add(null)
            resultTable.add(table.get("tableName"))
            resultTable.add(table.get("tableType"))
            resultTable.add(table.get(""))
            row = resultTable
            cnt = cnt + 1
            true
          } else {
            false
          }
        }
      }
    logger.info(s"resultSet is ${resultSet}")
    resultSet
  }