FlyingZC commented on issue #22026:
URL: 
https://github.com/apache/shardingsphere/issues/22026#issuecomment-1309848084

   The simle example to reproduce this issue:
   ```java
   import java.sql.Connection;
   import java.sql.DriverManager;
   import java.sql.ResultSet;
   import java.sql.SQLException;
   import java.sql.Statement;
   
   import static org.junit.Assert.assertEquals;
   
   public class SimpleTest {
       public static void main(String[] args) throws Exception {
           Connection conn1 = getConnection("localhost", 3307, "root", "root", 
"sharding_db");
           executeWithLog(conn1, "delete from account;");
           rollback();
       }
       
       public static void rollback() throws Exception {
           Connection conn2 = getConnection("localhost", 3307, "root", "root", 
"sharding_db");
           conn2.setAutoCommit(false);
           assertAccountRowCount(conn2, 0);
           Statement std1 = conn2.createStatement();
           std1.execute("insert into account(id, balance, transaction_id) 
values(1, 1, 1);");
           assertAccountRowCount(conn2, 1);
           conn2.rollback();
           assertAccountRowCount(conn2, 0);
       }
       
       private static Connection getConnection(String ip, int port, String 
user, String pwd, String db) throws SQLException {
           return 
DriverManager.getConnection(String.format("jdbc:opengauss://%s:%d/%s", ip, 
port, db), user, pwd);
       }
       
       protected static void assertAccountRowCount(final Connection conn, final 
int rowNum) {
           assertTableRowCount(conn, "account", rowNum);
       }
       
       protected static void assertTableRowCount(final Connection conn, final 
String tableName, final int rowNum) throws SQLException {
           Statement statement = conn.createStatement();
           ResultSet rs = statement.executeQuery("select * from " + tableName);
           int resultSetCount = 0;
           while (rs.next()) {
               resultSetCount++;
           }
           statement.close();
           assertEquals(String.format("Recode num assert error, expect: %s, 
actual: %s.", rowNum, resultSetCount), rowNum, resultSetCount);
       }
       
       public static void executeWithLog(final Connection connection, final 
String sql) {
           System.out.println("Connection execute: {}." + sql);
           connection.createStatement().execute(sql);
       }
   }
   ```
   
   
   yaml config-sharding:
   ```yaml
   databaseName: sharding_db
   
   dataSources:
     ds_0:
       url: jdbc:opengauss://localhost:15432/omm
       username: gaussdb
       password: x
       connectionTimeoutMilliseconds: 30000
       idleTimeoutMilliseconds: 60000
       maxLifetimeMilliseconds: 1800000
       maxPoolSize: 50
       minPoolSize: 1
     ds_1:
       url: jdbc:opengauss://localhost:15432/postgres
       username: gaussdb
       password: x
       connectionTimeoutMilliseconds: 30000
       idleTimeoutMilliseconds: 60000
       maxLifetimeMilliseconds: 1800000
       maxPoolSize: 50
       minPoolSize: 1
   
   rules:
     - !SHARDING
       tables:
         t_order:
           actualDataNodes: ds_${0..1}.t_order_${0..1}
           tableStrategy:
             standard:
               shardingColumn: order_id
               shardingAlgorithmName: t_order_inline
           keyGenerateStrategy:
             column: order_id
             keyGeneratorName: snowflake
         t_order_item:
           actualDataNodes: ds_${0..1}.t_order_item_${0..1}
           tableStrategy:
             standard:
               shardingColumn: order_id
               shardingAlgorithmName: t_order_item_inline
           keyGenerateStrategy:
             column: order_item_id
             keyGeneratorName: snowflake
       bindingTables:
         - t_order,t_order_item
       defaultDatabaseStrategy:
         standard:
           shardingColumn: user_id
           shardingAlgorithmName: database_inline
       defaultTableStrategy:
         none:
       
       shardingAlgorithms:
         database_inline:
           type: INLINE
           props:
             algorithm-expression: ds_${user_id % 2}
         t_order_inline:
           type: INLINE
           props:
             algorithm-expression: t_order_${order_id % 2}
         t_order_item_inline:
           type: INLINE
           props:
             algorithm-expression: t_order_item_${order_id % 2}
       
       keyGenerators:
         snowflake:
           type: SNOWFLAKE
   ```


-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: [email protected]

For queries about this service, please contact Infrastructure at:
[email protected]

Reply via email to