Update from oracle master

java/AoJ/README.md

@@ -1,55 +1,128 @@
-# AoJ: ADBA over JDBC
-
-ADBA is Asynchronous Database Access, a non-blocking database access api that Oracle is proposing as a Java standard. ADBA was announced at [JavaOne 2016](https://static.rainfocus.com/oracle/oow16/sess/1461693351182001EmRq/ppt/CONF1578%2020160916.pdf) and presented again at [JavaOne 2017](http://www.oracle.com/technetwork/database/application-development/jdbc/con1491-3961036.pdf). The ADBA source is available for download from the [OpenJDK sandbox](
-http://hg.openjdk.java.net/jdk/sandbox/file/9d3b0eb749a9/src/jdk.incubator.adba) as part of the OpenJDK project. You can get involved in the ADBA specification effort by following the [JDBC Expert Group mailing list](http://mail.openjdk.java.net/pipermail/jdbc-spec-discuss/). 
-
-Reading a bunch of JavaDoc and interfaces can be interesting, but it is not nearly as engaging as having actual running code to play with. To that end, we have uploaded the beginnings of an implementation of ADBA running over standard JDBC, AoJ. AoJ is available for download from [GitHub](https://github.com/oracle/oracle-db-examples/tree/master/java/AoJ) under the Apache license. It should run with any reasonably standard compliant JDBC driver.
-
-AoJ implements only a small part of ADBA, but it is enough to write interesting code. It provides partial implementations of DataSourceFactory, DataSource, Connection, OperationGroup, RowOperation, CountOperation, Transaction and others. These implementations are not complete but there is enough there to write interesting database programs. The code that is there is untested, but it does work to some extent. The saving grace is that you can download the source and improve it: add new features, fix bugs, try out alternate implementations.
-
-Oracle is not proposing AoJ as an open source project. However, because AoJ is released under the Apache license, the Java community can fork the code and create a true open source project with this upload as a base. Oracle developers may contribute when we have time, but this would have to be a Java community effort.
-
-We could have held this code back and worked on it longer. Instead we thought it better to get it to the community as soon as we could. We hope that you agree.
-
-## Sample Code
-
-The following test case should give you some idea of what AoJ can do. It uses the scott/tiger [schema](https://github.com/oracle/dotnet-db-samples/blob/master/schemas/scott.sql). It should run with any JDBC driver connecting to a database with the scott schema.
-
-`````` public void transactionSample() {
-   DataSourceFactory factory = DataSourceFactory.forName("com.oracle.adbaoverjdbc.DataSourceFactory");
-   try (DataSource ds = factory.builder()
-           .url(URL)
-           .username(“scott")
-           .password(“tiger")
-           .build();
-           Connection conn = ds.getConnection(t -> System.out.println("ERROR: " + t.getMessage()))) {
-     Transaction trans = conn.transaction();
-     CompletionStage<Integer> idF = conn.<Integer>rowOperation("select empno, ename from emp where ename = ? for update")
-             .set("1", "CLARK", AdbaType.VARCHAR)
-             .collect(Collector.of(
-                     () -> new int[1], 
-                     (a, r) -> {a[0] = r.get("empno", Integer.class); },
-                     (l, r) -> null,
-                     a -> a[0])
-             )
-             .submit()
-             .getCompletionStage();
-     conn.<Long>countOperation("update emp set deptno = ? where empno = ?")
-             .set("1", 50, AdbaType.INTEGER)
-             .set("2", idF, AdbaType.INTEGER)
-             .apply(c -> { 
-               if (c.getCount() != 1L) {
-                 trans.setRollbackOnly();
-                 throw new SqlException("updated wrong number of rows", null, null, -1, null, -1);
-               }
-               return c.getCount();
-             })
-             .onError(t -> t.printStackTrace())
-             .submit();
-     conn.catchErrors();
-     conn.commitMaybeRollback(trans);
-   }    
-   ForkJoinPool.commonPool().awaitQuiescence(1, TimeUnit.MINUTES);
- }
-
-
+# AoJ: ADBA over JDBC
+
+ADBA is Asynchronous Database Access, a non-blocking database access api that 
+Oracle is proposing as a Java standard. ADBA was announced at 
+[JavaOne 2016](https://static.rainfocus.com/oracle/oow16/sess/1461693351182001EmRq/ppt/CONF1578%2020160916.pdf) 
+and presented again at [JavaOne 2017](http://www.oracle.com/technetwork/database/application-development/jdbc/con1491-3961036.pdf). 
+The ADBA source is available for download from the [OpenJDK sandbox](http://hg.openjdk.java.net/jdk/sandbox/file/9d3b0eb749a9/src/jdk.incubator.adba) 
+as part of the OpenJDK project and the JavaDoc is available [here](http://cr.openjdk.java.net/~lancea/8188051/apidoc/jdk.incubator.adba-summary.html). 
+You can get involved in the ADBA specification effort by following the 
+[JDBC Expert Group mailing list](http://mail.openjdk.java.net/pipermail/jdbc-spec-discuss/). 
+
+Reading a bunch of JavaDoc and interfaces can be interesting, but it is not nearly 
+as engaging as having actual running code to play with. To that end, we have 
+uploaded the beginnings of an implementation of ADBA running over standard JDBC, 
+AoJ. AoJ is available for download from [GitHub](https://github.com/oracle/oracle-db-examples/tree/master/java/AoJ) 
+under the Apache license. It should run with any reasonably standard compliant 
+JDBC driver.
+
+AoJ implements only a small part of ADBA, but it is enough to write interesting 
+code. It provides partial implementations of ```DataSourceFactory```, ```DataSource```, 
+```Connection```, ```OperationGroup```, ```RowOperation```, ```CountOperation```, 
+```Transaction``` and others. These implementations are not complete but there is 
+enough there to write interesting database programs. The code that is there is 
+untested, but it does work to some extent. The saving grace is that you can 
+download the source and improve it: add new features, fix bugs, try out alternate 
+implementations.
+
+Oracle is not proposing AoJ as an open source project. However, because AoJ is 
+released under the Apache license, the Java community can fork the code and create 
+a true open source project with this upload as a base. Oracle developers may 
+contribute when we have time, but this would have to be a Java community effort.
+
+We could have held this code back and worked on it longer. Instead we thought it 
+better to get it to the community as soon as we could. We hope that you agree.
+
+## Building AoJ
+
+AoJ and ADBA require JDK 9 or later. Download ADBA from the 
+[OpenJDK sandbox](http://hg.openjdk.java.net/jdk/sandbox/file/JDK-8188051-branch/src/jdk.incubator.adba/share/classes). It does not have any dependencies outside of Java SE. 
+
+For building the API modules:
+```
+$ mkdir -p mods/jdk.incubator.adba
+$ javac -d mods/jdk.incubator.adba/ $(find jdk.incubator.adba  -name "*.java")
+$ jar --create --file=mlib/jdk.incubator.adba.jar --module-version=1.0 -C mods/jdk.incubator.adba/ .
+````
+Download AoJ from 
+[GitHub](https://github.com/oracle/oracle-db-examples/tree/master/java/AoJ).  Both 
+are modularized so be sure to include the module-info.java files. AoJ depends on 
+ADBA. The AoJ sample file depends on JUnit which is included with most IDEs but is 
+also available [here](https://github.com/junit-team/junit4). 
+
+To run the sample file you will need a SQL database and corresponding JDBC driver. AoJ 
+has been run with [Oracle Database 12c](http://www.oracle.com/technetwork/database/enterprise-edition/downloads/index.html)
+and [Oracle Database 12c JDBC](http://www.oracle.com/technetwork/database/application-development/jdbc/downloads/index.html),
+but it should work with any reasonably standard compliant SQL database and JDBC
+driver. The sample file uses the scott/tiger schema available 
+[here](https://github.com/oracle/dotnet-db-samples/blob/master/schemas/scott.sql).
+
+Start the database and load ```scott.sql```. Edit ```com.oracle.adbaoverjdbc.test.FirstLight.java```
+and set the constant ```URL``` to an appropriate value. AoJ will pass this value
+to ```java.sql.DriverManager.getConnection```. If you are using a database other
+than Oracle you should change the value of the constant ```TRIVIAL``` to some
+very trivial ```SELECT``` query.
+
+## Sample Code
+
+The following test case should give you some idea of what AoJ can do. It  should
+run with any JDBC driver connecting to a database with the scott schema. This is
+the last test in ```com.oracle.adbaoverjdbc.test.FirstLight.java```. For an 
+introduction to ADBA see the [JavaOne 2017 presentation](http://www.oracle.com/technetwork/database/application-development/jdbc/con1491-3961036.pdf). 
+
+
+```public void transactionSample() {
+   // get the AoJ DataSourceFactory
+   DataSourceFactory factory = DataSourceFactory.forName("com.oracle.adbaoverjdbc.DataSourceFactory");
+   // get a DataSource and a Connection
+   try (DataSource ds = factory.builder()
+           .url(URL)
+           .username(“scott")
+           .password(“tiger")
+           .build();
+           Connection conn = ds.getConnection(t -> System.out.println("ERROR: " + t.getMessage()))) {
+     // get a Transaction
+     Transaction trans = conn.transaction();
+     // select the EMPNO of CLARK
+     CompletionStage<Integer> idF = conn.<Integer>rowOperation("select empno, ename from emp where ename = ? for update")
+             .set("1", "CLARK", AdbaType.VARCHAR)
+             .collect(Collector.of(
+                     () -> new int[1], 
+                     (a, r) -> {a[0] = r.get("empno", Integer.class); },
+                     (l, r) -> null,
+                     a -> a[0])
+             )
+             .submit()
+             .getCompletionStage();
+     // update CLARK to work in department 50
+     conn.<Long>countOperation("update emp set deptno = ? where empno = ?")
+             .set("1", 50, AdbaType.INTEGER)
+             .set("2", idF, AdbaType.INTEGER)
+             .apply(c -> { 
+               if (c.getCount() != 1L) {
+                 trans.setRollbackOnly();
+                 throw new SqlException("updated wrong number of rows", null, null, -1, null, -1);
+               }
+               return c.getCount();
+             })
+             .onError(t -> t.printStackTrace())
+             .submit();
+
+     conn.catchErrors();  // resume normal execution if there were any errors
+     conn.commitMaybeRollback(trans); // commit (or rollback) the transaction
+   }  
+   // wait for the async tasks to complete before exiting  
+   ForkJoinPool.commonPool().awaitQuiescence(1, TimeUnit.MINUTES);
+ }
+``` 
+
+## AoJ Design Spec in 100 words or less
+
+The methods called by the user thread create a network 
+(i.e., [DAG](https://en.wikipedia.org/wiki/Directed_acyclic_graph)) of 
+```CompletableFuture```s. These ```CompleteableFuture```s asynchronously execute 
+the synchronous JDBC calls and the result processing code provided by the user 
+code. By default AoJ uses ```ForkJoinPool.commonPool()``` to execute 
+```CompletableFuture```s but the user code can provide another ```Executor```.
+When the ```Connection``` is submitted the root of the ```CompleteableFuture```
+network is completed triggering execution of the rest of the network.

java/AoJ/sql/README.md

@@ -0,0 +1,3 @@
+# Derby SQL
+
+For use with AoJ (slitghly different from Oracle SQL)

java/AoJ/sql/derby.adba copy.sql

@@ -0,0 +1,35 @@
+connect 'jdbc:derby:adbaDB;create=true';
+DROP TABLE EMP;
+DROP TABLE DEPT;
+CREATE TABLE DEPT(DEPTNO NUMERIC(2), DNAME VARCHAR(14), LOC VARCHAR(13), PRIMARY KEY(DEPTNO));
+CREATE TABLE EMP(EMPNO NUMERIC(4), ENAME VARCHAR(10), JOB VARCHAR(9), MGR NUMERIC(4), HIREDATE DATE, SAL NUMERIC(7,2), COMM NUMERIC(7,2), DEPTNO NUMERIC(2), PRIMARY KEY(EMPNO), foreign key(DEPTNO) references DEPT);
+INSERT INTO DEPT VALUES(10,'ACCOUNTING','NEW YORK');
+INSERT INTO DEPT VALUES (20,'RESEARCH','DALLAS');
+INSERT INTO DEPT VALUES(30,'SALES','CHICAGO');
+INSERT INTO DEPT VALUES(40,'OPERATIONS','BOSTON');
+INSERT INTO EMP VALUES(7369,'SMITH','CLERK',7902, date('1980-12-17'), 800,NULL,20);
+INSERT INTO EMP VALUES(7499,'ALLEN','SALESMAN',7698, date('1981-02-20'), 1600, 300, 30);
+INSERT INTO EMP VALUES(7521,'WARD','SALESMAN',7698, date('1981-02-22'), 1250, 500, 30);
+INSERT INTO EMP VALUES(7566,'JONES','MANAGER', 7839, date('1981-04-02'), 2975, NULL, 20);
+INSERT INTO EMP VALUES(7654,'MARTIN','SALESMAN',7698, date('1981-09-28'), 1250,1400, 30);
+INSERT INTO EMP VALUES(7698,'BLAKE','MANAGER',7839, date('1981-05-01'), 2850, NULL, 30);
+INSERT INTO EMP VALUES(7782,'CLARK','MANAGER',7839, date('1981-06-05'), 2450, NULL, 10);
+INSERT INTO EMP VALUES(7788,'SCOTT','ANALYST',7566, date('1987-07-13'), 3000, NULL, 20);
+INSERT INTO EMP VALUES(7839,'KING','PRESIDENT',NULL, date('1981-11-17'), 5000, NULL, 10);
+
+INSERT INTO EMP VALUES(7844,'TURNER','SALESMAN',7698, date('1981-09-08'), 1500, 0, 30);
+INSERT INTO EMP VALUES(7876,'ADAMS','CLERK',7788, date('1987-07-13'), 1100, NULL, 20);
+INSERT INTO EMP VALUES(7900,'JAMES','CLERK',7698, date('1981-12-03'), 950, NULL, 30);
+INSERT INTO EMP VALUES(7902,'FORD','ANALYST',7566, date('1981-12-03'), 3000, NULL, 20);
+INSERT INTO EMP VALUES(7934,'MILLER','CLERK',7782, date('1982-01-23'), 1300, NULL, 10);
+
+DROP TABLE BONUS;;
+CREATE TABLE BONUS(ENAME VARCHAR(10), JOB VARCHAR(9)  ,SAL NUMERIC(7,2),COMM NUMERIC(7,2)) ;
+DROP TABLE SALGRADE;
+CREATE TABLE SALGRADE( GRADE NUMERIC,LOSAL NUMERIC(7,2),HISAL NUMERIC(7,2));
+
+INSERT INTO SALGRADE VALUES (1,700,1200);
+INSERT INTO SALGRADE VALUES (2,1201,1400);
+INSERT INTO SALGRADE VALUES (3,1401,2000);
+INSERT INTO SALGRADE VALUES (4,2001,3000);
+INSERT INTO SALGRADE VALUES (5,3001,9999);

java/AoJ/src/com/oracle/adbaoverjdbc/com/oracle/adbaoverjdbc/Connection.java

@@ -225,14 +225,22 @@ jdk.incubator.sql2.Submission<Object> submit(com.oracle.adbaoverjdbc.Operation<O
     }
   }
 
+  protected <V> V connectionPropertyValue(ConnectionProperty prop) {
+    V value = (V)properties.get(prop);
+    if (value == null) return (V)prop.defaultValue();
+    else return value;
+  }
+
 
 
 
   // JDBC operations. These are all blocking
 
   private Void jdbcConnect(com.oracle.adbaoverjdbc.Operation<Void> op) {
     try {
-    Properties info = (Properties) ((Properties) properties.get(JdbcConnectionProperties.JDBC_CONNECTION_PROPERTIES)).clone();
+    Properties info = (Properties)properties.get(JdbcConnectionProperties.JDBC_CONNECTION_PROPERTIES);
+    info = (Properties)(info == null ? JdbcConnectionProperties.JDBC_CONNECTION_PROPERTIES.defaultValue() 
+                                     : info.clone());
     info.setProperty("user", (String) properties.get(AdbaConnectionProperty.USER));
     info.setProperty("password", (String) properties.get(AdbaConnectionProperty.PASSWORD));
     String url = (String) properties.get(AdbaConnectionProperty.URL);

java/AoJ/src/com/oracle/adbaoverjdbc/com/oracle/adbaoverjdbc/Operation.java

@@ -48,24 +48,20 @@ abstract class Operation<T> implements jdk.incubator.sql2.Operation<T> {
   private static final Map<Class, SQLType> CLASS_TO_JDBCTYPE = new HashMap<>(20);
   static {
     try {
-      CLASS_TO_JDBCTYPE.put(Boolean.class, JDBCType.BOOLEAN);
       CLASS_TO_JDBCTYPE.put(BigInteger.class, JDBCType.BIGINT);
-      CLASS_TO_JDBCTYPE.put(Class.forName("[B"), JDBCType.BINARY);
-      CLASS_TO_JDBCTYPE.put(Boolean.class, JDBCType.BIT);
       CLASS_TO_JDBCTYPE.put(Boolean.class, JDBCType.BOOLEAN);
+      CLASS_TO_JDBCTYPE.put(Byte.class, JDBCType.TINYINT);
+      CLASS_TO_JDBCTYPE.put(Class.forName("[B"), JDBCType.VARBINARY);
       CLASS_TO_JDBCTYPE.put(Character.class, JDBCType.CHAR);
-      CLASS_TO_JDBCTYPE.put(LocalDate.class, JDBCType.DATE);
       CLASS_TO_JDBCTYPE.put(Double.class, JDBCType.DOUBLE);
       CLASS_TO_JDBCTYPE.put(Float.class, JDBCType.FLOAT);
       CLASS_TO_JDBCTYPE.put(Integer.class, JDBCType.INTEGER);
-      CLASS_TO_JDBCTYPE.put(Float.class, JDBCType.REAL);
-      CLASS_TO_JDBCTYPE.put(Short.class, JDBCType.SMALLINT);
-      CLASS_TO_JDBCTYPE.put(LocalTime.class, JDBCType.TIME);
+      CLASS_TO_JDBCTYPE.put(LocalDate.class, JDBCType.DATE);
       CLASS_TO_JDBCTYPE.put(LocalDateTime.class, JDBCType.TIMESTAMP);
-      CLASS_TO_JDBCTYPE.put(OffsetTime.class, JDBCType.TIME_WITH_TIMEZONE);
+      CLASS_TO_JDBCTYPE.put(LocalTime.class, JDBCType.TIME);
       CLASS_TO_JDBCTYPE.put(OffsetDateTime.class, JDBCType.TIMESTAMP_WITH_TIMEZONE);
-      CLASS_TO_JDBCTYPE.put(Byte.class, JDBCType.TINYINT);
-      CLASS_TO_JDBCTYPE.put(Class.forName("[byte"), JDBCType.VARBINARY);
+      CLASS_TO_JDBCTYPE.put(OffsetTime.class, JDBCType.TIME_WITH_TIMEZONE);
+      CLASS_TO_JDBCTYPE.put(Short.class, JDBCType.SMALLINT);
       CLASS_TO_JDBCTYPE.put(String.class, JDBCType.VARCHAR);
     }
     catch (ClassNotFoundException ex) { /* should never happen */ }
@@ -88,9 +84,9 @@ abstract class Operation<T> implements jdk.incubator.sql2.Operation<T> {
     ADBATYPE_TO_JDBCTYPE.put(AdbaType.FLOAT, JDBCType.FLOAT);
     ADBATYPE_TO_JDBCTYPE.put(AdbaType.INTEGER, JDBCType.INTEGER);
     ADBATYPE_TO_JDBCTYPE.put(AdbaType.JAVA_OBJECT, JDBCType.JAVA_OBJECT);
-    ADBATYPE_TO_JDBCTYPE.put(AdbaType.LONGNVARCHAR, JDBCType.LONGNVARCHAR);
-    ADBATYPE_TO_JDBCTYPE.put(AdbaType.LONGVARBINARY, JDBCType.LONGVARBINARY);
-    ADBATYPE_TO_JDBCTYPE.put(AdbaType.LONGVARCHAR, JDBCType.LONGVARBINARY);
+    ADBATYPE_TO_JDBCTYPE.put(AdbaType.LONG_NVARCHAR, JDBCType.LONGNVARCHAR);
+    ADBATYPE_TO_JDBCTYPE.put(AdbaType.LONG_VARBINARY, JDBCType.LONGVARBINARY);
+    ADBATYPE_TO_JDBCTYPE.put(AdbaType.LONG_VARCHAR, JDBCType.LONGVARBINARY);
     ADBATYPE_TO_JDBCTYPE.put(AdbaType.NCHAR, JDBCType.NCHAR);
     ADBATYPE_TO_JDBCTYPE.put(AdbaType.NCLOB, JDBCType.NCLOB);
     ADBATYPE_TO_JDBCTYPE.put(AdbaType.NULL, JDBCType.NULL);

java/AoJ/src/com/oracle/adbaoverjdbc/com/oracle/adbaoverjdbc/OperationGroup.java

@@ -16,13 +16,11 @@
 package com.oracle.adbaoverjdbc;
 
 import jdk.incubator.sql2.ArrayCountOperation;
-import jdk.incubator.sql2.DynamicMultiOperation;
 import jdk.incubator.sql2.LocalOperation;
 import jdk.incubator.sql2.OutOperation;
 import jdk.incubator.sql2.ParameterizedCountOperation;
 import jdk.incubator.sql2.ParameterizedRowOperation;
 import jdk.incubator.sql2.RowProcessorOperation;
-import jdk.incubator.sql2.StaticMultiOperation;
 import jdk.incubator.sql2.Submission;
 import jdk.incubator.sql2.Transaction;
 import jdk.incubator.sql2.TransactionOutcome;
@@ -34,6 +32,7 @@
 import java.util.function.Consumer;
 import java.util.logging.Logger;
 import java.util.stream.Collector;
+import jdk.incubator.sql2.MultiOperation;
 
 /**
  * Only sequential, dependent, unconditional supported.
@@ -205,13 +204,7 @@ public <R extends S> RowProcessorOperation<R> rowProcessorOperation(String sql)
   }
 
   @Override
-  public <R extends S> StaticMultiOperation<R> staticMultiOperation(String sql) {
-    if ( ! isHeld() ) throw new IllegalStateException("TODO");
-    throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
-  }
-
-  @Override
-  public <R extends S> DynamicMultiOperation<R> dynamicMultiOperation(String sql) {
+  public <R extends S> MultiOperation<R> multiOperation(String sql) {
     if ( ! isHeld() ) throw new IllegalStateException("TODO");
     throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
   }