missinng-udfs.diff

Igor Skornyakov, 07/12/2022 12:00 PM

     **     IAS 20220324          Re-worked LockTableUpdater.
     **     OM  20220516          Added collation support for _meta databases (use the H2 dialect).
     **     IAS 20220608          Provide additional information in reportUDFVersion().
     **     IAS 20220712          Create missing UDFs
     */
     /*
-...
     import java.util.logging.*;
     import com.goldencode.cache.*;
     import com.goldencode.p2j.main.*;
     import com.goldencode.p2j.persist.deploy.*;
     import com.goldencode.p2j.persist.dialect.*;
     import com.goldencode.p2j.persist.event.*;
     import com.goldencode.p2j.persist.hql.*;
-...
           String searchPath = "unknown";
           try (Session session = new Session(database);
                Statement st = session.getConnection().createStatement())
                Connection conn = session.getConnection())
+          {
              String sqlFunc = HQLPreprocessor.getRegisteredFunction(database, "getFWDVersion", null);
              if (sqlFunc == null)
+             {
                 sqlFunc = "getFWDVersion"; // the function is not overloaded for all dialects
+             }
              useSQLUdfs = (dialect instanceof P2JPostgreSQLDialect) &&
              useSQLUdfs = dialect.isNativeUDFsSupported() &&
                       !DatabaseManager.getConfiguration(database).isUseJavaUDFs();
              if (useSQLUdfs && !sqlFunc.startsWith("udf."))
              if (useSQLUdfs)
+             {
                 sqlFunc = "udf." + sqlFunc;
                 ScriptRunner.createMissingUdfs(database);
                 if (!sqlFunc.startsWith("udf."))
+                {
                    sqlFunc = "udf." + sqlFunc;
+                }
+             }
              try
              try(Statement st = conn.createStatement();
                 ResultSet rs = st.executeQuery("SELECT " + sqlFunc + "()"))
+             {
                 ResultSet rs = st.executeQuery("SELECT " + sqlFunc + "()");
                 if (rs.next())
+                {
                    String val = rs.getString(1);
-...
+             }
              if (dialect instanceof P2JPostgreSQLDialect)
+             {
                 try
                 try(Statement st = conn.createStatement();
                     ResultSet rs = st.executeQuery(
                                   "SELECT setting FROM pg_settings WHERE name='search_path'"))
+                {
                    ResultSet rs = st.executeQuery(
                             "SELECT setting FROM pg_settings WHERE name='search_path'");
                    if (rs.next())
+                   {
                       String val = rs.getString(1);

     **     IAS 20220608 Add option for setting database search_path.
     **     IAS 20220610 Create 'scale' UDF if PostgreSQL major version is < 10.
     **     OM  20220614 Dropped unused import. Formatting javadoc and typo fixes.
     **     IAS 20220712 Create missing UDFs
     */
     /*
-...
     import java.util.regex.*;
     import java.util.stream.*;
     import com.goldencode.p2j.cfg.*;
     import com.goldencode.p2j.persist.*;
     import com.goldencode.p2j.persist.deploy.ScriptSplitter.*;
     import com.goldencode.p2j.persist.dialect.*;
     import com.goldencode.p2j.persist.orm.*;
     import com.goldencode.p2j.util.*;
     /** Run SQL script against PostgreSQL database */
-...
              "$function$"
+          )
        );
        private static final List<String> COUNT = Collections.unmodifiableList(
                 Arrays.asList(
                    "select count(*)",
                    "from pg_proc p",
                    "left join pg_namespace n on p.pronamespace = n.oid",
                    "left join pg_language l on p.prolang = l.oid",
                    "left join pg_type t on t.oid = p.prorettype",
                    "where n.nspname = ?",
                    "  and l.lanname in ('sql', 'plpgsql')",
                    "  and t.typname != 'trigger'",
                    "  and p.proname = ?"
+                )
              );
        /**
         * Runner main method.
+        *
-...
+          {
              throw new IllegalArgumentException("Unknown JDBC database type: [" + dbtype + "]");
+          }
           ScriptSplitter splitter = dialect.scripSplitter();
           List<String> scriptNames;
           List<String> scripts;
           boolean setSearchPath = false;
           boolean createScale = false;
           switch (args[3])
-...
              case "udf.install.search_path":
                 setSearchPath = true;
              case "udf.install":
                 String[] scripts;
                 if (args.length > 4)
+                {
                    scripts = args[4].split("\\s+");
                    scripts = Arrays.asList(args[4].split("\\s+"));
+                }
                 else
+                {
                    scripts = new String[] {"udfs.sql", "words-udfs-sql.sql"};
                    scripts = Arrays.asList("udfs.sql", "words-udfs-sql.sql");
+                }
                 scriptNames = Arrays.stream(scripts).map(s -> "/udf/" + dbtype + "/" + s).
                          collect(Collectors.toList());
                 break;
              default:
                 throw new IllegalArgumentException("Unknown command: [" + args[3] + "]");
-...
           try(Connection conn = DriverManager.getConnection(args[0], args[1], args[2]))
+          {
              boolean isPostgreSQL =  "postgresql".equalsIgnoreCase(
                       conn.getMetaData().getDatabaseProductName());
              if (isPostgreSQL && getPgVersion(conn) < 1000)
+             {
                 createScaleUDF(conn);
+             }
              for (String scriptName: scriptNames)
+             {
                 InputStream is = ScriptRunner.class.getResourceAsStream(scriptName);
                 if (is == null)
+                {
                    throw new IllegalStateException("Cannot open script [" + scriptName + "]" );
+                }
                 try(BufferedReader br = new BufferedReader(new InputStreamReader(is)))
+                {
                    LOG.log(Level.INFO, "Running script: [{}]", scriptName);
                    runScript(conn, br, splitter);
+                }
+             }
              if (setSearchPath && isPostgreSQL)
+             {
                 String dbname = null;
                 try(Statement stmt = conn.createStatement())
+                {
                    ResultSet rs = stmt.executeQuery("SELECT current_database()");
                    if( rs.next())
+                   {
                       dbname = rs.getString(1);
+                   }
+                }
                 if (dbname != null)
+                {
                    LOG.log(Level.INFO, "Setting search_path for [{}]", dbname);
                    execute(conn, "ALTER DATABASE " + dbname + " SET search_path TO public,udf");
+                }
                 else
+                {
                    LOG.log(Level.WARNING, "Failed to retrieve the database name");
+                }
              apply(dialect, scripts, setSearchPath, conn);
+          }
+       }
        /**
         * Check for missing UDFs and create them.
+        *
         * @param db
         *       Database.
         * @throws SQLException
         *         on SQL error.
         * @throws PersistenceException
         *         on script reading error.
         */
        public static void createMissingUdfs(Database db)
        throws SQLException,
               PersistenceException
+       {
           String dbname = db.getName();
           Dialect dialect = DatabaseManager.getDialect(db);
           Settings orm = DatabaseManager.getConfiguration(db).getOrmSettings();
           String url = orm.getString(Settings.URL, null);
           String adm = orm.getString(Settings.ADMIN, null);
           String pwd = orm.getString(Settings.ADMIN_PASSWORD, null);
           if (adm == null || pwd == null)
+          {
              LOG.info("No admin credentials provided, skipping missing UDFs analysis");
              return;
+          }
           List<String> scripts = new ArrayList<>();
           try(Connection conn = DriverManager.getConnection(url, adm, pwd))
+          {
              if (countUDFs(conn, "udf", "getfwdversion") == 0)
+             {
                 LOG.info(String.format("%s UDF not found in %s; %s SQL script will be applied",
                          "'udf.getfwdversion'", dbname, "'udfs.sql'"));
                 scripts.add("udfs.sql");
+             }
              if (countUDFs(conn, "public", "words") < 2)
+             {
                 LOG.info(String.format("Less than 2 %s UDFs found in %s; %s SQL script will be applied",
                          "'public.words'", dbname, "'words-udfs-sql.sql'"));
                 scripts.add("words-udfs-sql.sql");
+             }
              try
+             {
                 apply(dialect, scripts, false, conn);
+             }
              catch (IOException e)
+             {
                 throw new PersistenceException(e);
+             }
+          }
+       }
        /**
         * Apply SQL scripts.
         * @param dialect
         *        Database dialect.
         * @param scripts
         *        Scripts to be applied.
         * @param setSearchPath
         *        Flag indicating that serach path should be set.
         * @param conn
         *        Database connection.
         * @throws SQLException
         *         on SQL error.
         * @throws IOException
         *         on script reading error.
         */
        private static void apply(Dialect dialect, List<String> scripts,
                 boolean setSearchPath, Connection conn) throws SQLException, IOException
+       {
           ScriptSplitter splitter = dialect.scripSplitter();
           List<String> scriptNames = scripts.stream().
                    map(s -> "/udf/" + dialect.getJdbcType() + "/" + s).
                    collect(Collectors.toList());
           boolean isPostgreSQL =  "postgresql".equalsIgnoreCase(
                    conn.getMetaData().getDatabaseProductName());
           if (isPostgreSQL && getPgVersion(conn) < 1000)
+          {
              createScaleUDF(conn);
+          }
           for (String scriptName: scriptNames)
+          {
              InputStream is = ScriptRunner.class.getResourceAsStream(scriptName);
              if (is == null)
+             {
                 throw new IllegalStateException("Cannot open script [" + scriptName + "]" );
+             }
              try(BufferedReader br = new BufferedReader(new InputStreamReader(is)))
+             {
                 LOG.log(Level.INFO, String.format("Running script: [%s]", scriptName));
                 runScript(conn, br, splitter);
+             }
+          }
           if (setSearchPath && isPostgreSQL)
+          {
              String dbname = null;
              try(Statement stmt = conn.createStatement();
                  ResultSet rs = stmt.executeQuery("SELECT current_database()"))
+             {
                 if( rs.next())
+                {
                    dbname = rs.getString(1);
+                }
+             }
              if (dbname != null)
+             {
                 LOG.log(Level.INFO, String.format("Setting search_path for [%s]", dbname));
                 execute(conn, "ALTER DATABASE " + dbname + " SET search_path TO public,udf");
+             }
              else
+             {
                 LOG.log(Level.WARNING, "Failed to retrieve the database name");
+             }
+          }
+       }
-...
         *          The database connection.
+        *
         * @throws  SQLException
         *          Oon error.
         *          On error.
         */
        private static void createScaleUDF(Connection conn)
        throws SQLException
-...
           String sql = SCALE.stream().collect(Collectors.joining(eoln));
           execute(conn, sql);
+       }
        /**
         * Count number of UDFs with a given name.
         * @param   conn
         *          The database connection.
         * @param   schema
         *          schema name.
         * @param   name
         *          UDF name.
         * @return  number of UDFs with a given name.
         * @throws  SQLException
         *          On error.
         */
        private static int countUDFs(Connection conn, String schema, String name)
        throws SQLException
+       {
           String eoln = EnvironmentOps.OS_WIN.equalsIgnoreCase(Configuration.getParameter("opsys"))
                 ? "\r\n" /* express to WINDOWS */ : "\n" /* default to Linux */;
           String sql = COUNT.stream().collect(Collectors.joining(eoln));
           try (PreparedStatement pstmt = conn.prepareStatement(sql))
+          {
              int n = 0;
              pstmt.setString(1, schema);
              pstmt.setString(2, name);
              ResultSet rs = pstmt.executeQuery();
              if (rs.next())
+             {
                 n = rs.getInt(1);
+             }
              return n;
+          }
+       }
+    }

     **     OM  20210412          Replace Hibernate-specific casts with dialect-specific casts
     **     IAS 20211223          Special processing of errors raised by UDFs.
     **     IAS 20220112          Resolve dialect by JDBC database type.
     **     IAS 20220602          Added  isNativeUDFsSupported() method
     **     IAS 20220602          Added isNativeUDFsSupported() method.
     **     IAS 20220712          Added getJdbcType() method.
     */
     /*
-...
         */
        public abstract ScriptSplitter scripSplitter();
        /**
         * Get the dialect JDBC type.
         * @return dialect JDBC type.
         */
        public abstract String getJdbcType();
        /**
         * Create a {@link Blob} instance from the specified bytes.
+        *

     **     OM  20210908          Used SchemaDictionary.TEMP_TABLE_DB instead of hardcoded constant.
     **     IAS 20211223          Special processing of errors raised by UDFs.
     **     IAS 20220112          Resolve dialect by JDBC database type.
     **     IAS 20220602          Added  isNativeUDFsSupported() method
     **     IAS 20220602          Added isNativeUDFsSupported() method.
     **     IAS 20220712          Added getJdbcType() method.
     */
     /*
-...
+       }
        /**
         * Get the dialect JDBC type.
         * @return dialect JDBC type.
         */
        public String getJdbcType()
+       {
           return "h2";
+       }
        /**
         * Create a {@link Blob} instance from the specified bytes.
+        *

     **     IAS 20220112          Resolve dialect by JDBC database type.
     **     TJD 20220331          Removed reference to IOUtils.toInputStream
     **     IAS 20220601          Do not emit 'words' UDFs definitions
     **     IAS 20220602          Added  isNativeUDFsSupported() method
     **     IAS 20220602          Added isNativeUDFsSupported() method.
     **     IAS 20220712          Added getJdbcType() method.
     */
     /*
-...
           return new PgScriptSplitter();
+       }
        /**
         * Get the dialect JDBC type.
         * @return dialect JDBC type.
         */
        public String getJdbcType()
+       {
           return "postgresql";
+       }
        /**
         * Create a {@link Blob} instance from the specified bytes.
+        *

     **     CA  20210305 The object and handle fields have a Long representation at the SQL table field.
     **     IAS 20211223 Special processing of errors raised by UDFs (placeholder).
     **     IAS 20220112 Resolve dialect by JDBC database type.
     **     IAS 20220602          Added  isNativeUDFsSupported() method
     **     IAS 20220602 Added isNativeUDFsSupported() method.
     **     IAS 20220712 Added getJdbcType() method.
     */
     /*
-...
           throw new UnsupportedOperationException();
+       }
        /**
         * Get the dialect JDBC type.
         * @return dialect JDBC type.
         */
        public String getJdbcType()
+       {
           return "sqlserver";
+       }
        /**
         * Create a {@link Blob} instance from the specified bytes.
+        *

     ** Module   : Settings.java
     ** Abstract : Configuration information required for the ORM framework
     **
     ** Copyright (c) 2019-2020, Golden Code Development Corporation.
     ** Copyright (c) 2019-2022, Golden Code Development Corporation.
     **
     ** -#- -I- --Date-- ---------------------------------Description---------------------------------
     ** 001 ECF 20191001 Created initial version. ORM layer configuration information.
-...
     ** 003 AIL 20200918 Made Settings use the dynamically computed URL for per-session databases.
     ** 004 AIL 20201016 Increased searching interval for getAllForCategory.
     ** 005 IAS 20201219 Added 'CPSTREAM' import task argument
     ** 006 IAS 20220712 Added admin login/pwd values.
     */
     /*
-...
        /** Connection password key */
        public static final String PASSWORD = "connection.password";
        /** Connection uadmin name key */
        public static final String ADMIN = "connection.admin_username";
        /** Connection password key */
        public static final String ADMIN_PASSWORD = "connection.admin_password";
        /** table dump file codepage, optional */
        public static final String CPSTREAM = "dump.cpstream";

Project

General

Profile

FWD » Core Development » Database

missinng-udfs.diff