Merge pull request cockroachdb#3366 from cockroachdb/includes_cleanup

Cleanup versioning in _includes

Author: Jesse Seldess

CONTRIBUTING.md

@@ -0,0 +1,34 @@
+import java.sql.*;
+
+/*
+You can compile and run this example with a command like:
+  javac BasicSample.java && java -cp .:~/path/to/postgresql-9.4.1208.jar BasicSample
+You can download the postgres JDBC driver jar from https://jdbc.postgresql.org.
+*/
+public class BasicSample {
+    public static void main(String[] args) throws ClassNotFoundException, SQLException {
+        // Load the postgres JDBC driver.
+        Class.forName("org.postgresql.Driver");
+
+        // Connect to the "bank" database.
+        Connection db = DriverManager.getConnection("jdbc:postgresql://127.0.0.1:26257/bank?sslmode=disable", "maxroach", "");
+
+        try {
+            // Create the "accounts" table.
+            db.createStatement().execute("CREATE TABLE IF NOT EXISTS accounts (id INT PRIMARY KEY, balance INT)");
+
+            // Insert two rows into the "accounts" table.
+            db.createStatement().execute("INSERT INTO accounts (id, balance) VALUES (1, 1000), (2, 250)");
+
+            // Print out the balances.
+            System.out.println("Initial balances:");
+            ResultSet res = db.createStatement().executeQuery("SELECT id, balance FROM accounts");
+            while (res.next()) {
+                System.out.printf("\taccount %s: %s\n", res.getInt("id"), res.getInt("balance"));
+            }
+        } finally {
+            // Close the database connection.
+            db.close();
+        }
+    }
+}

_includes/expand.html

@@ -0,0 +1,113 @@
+import java.sql.*;
+
+/*
+  You can compile and run this example with a command like:
+  javac TxnSample.java && java -cp .:~/path/to/postgresql-9.4.1208.jar TxnSample
+  You can download the postgres JDBC driver jar from https://jdbc.postgresql.org.
+*/
+
+// Ambiguous whether the transaction committed or not.
+class AmbiguousCommitException extends SQLException{
+    public AmbiguousCommitException(Throwable cause) {
+        super(cause);
+    }
+}
+class InsufficientBalanceException extends Exception {}
+class AccountNotFoundException extends Exception {
+    public int account;
+    public AccountNotFoundException(int account) {
+        this.account = account;
+    }
+}
+
+// A simple interface that provides a retryable lambda expression.
+interface RetryableTransaction {
+    public void run(Connection conn)
+        throws SQLException, InsufficientBalanceException, AccountNotFoundException, AmbiguousCommitException;
+}
+
+public class TxnSample {
+    public static RetryableTransaction transferFunds(int from, int to, int amount) {
+        return new RetryableTransaction() {
+            public void run(Connection conn)
+                throws SQLException, InsufficientBalanceException, AccountNotFoundException, AmbiguousCommitException {
+                // Check the current balance.
+                ResultSet res = conn.createStatement().executeQuery("SELECT balance FROM accounts WHERE id = " + from);
+                if(!res.next()) {
+                    throw new AccountNotFoundException(from);
+                }
+                int balance = res.getInt("balance");
+                if(balance < from) {
+                    throw new InsufficientBalanceException();
+                }
+                // Perform the transfer.
+                conn.createStatement().executeUpdate("UPDATE accounts SET balance = balance - " + amount + " where id = " + from);
+                conn.createStatement().executeUpdate("UPDATE accounts SET balance = balance + " + amount + " where id = " + to);
+            }
+        };
+    }
+
+    public static void retryTransaction(Connection conn, RetryableTransaction tx)
+        throws SQLException, InsufficientBalanceException, AccountNotFoundException, AmbiguousCommitException {
+        Savepoint sp = conn.setSavepoint("cockroach_restart");
+        while(true) {
+            boolean releaseAttempted = false;
+            try {
+                tx.run(conn);
+                releaseAttempted = true;
+                conn.releaseSavepoint(sp);
+            }
+            catch(SQLException e) {
+                String sqlState = e.getSQLState();
+                // Check if the error code indicates a SERIALIZATION_FAILURE.
+                if(sqlState.equals("40001")) {
+                    // Signal the database that we will attempt a retry.
+                    conn.rollback(sp);
+                    continue;
+                } else if(releaseAttempted) {
+                    throw new AmbiguousCommitException(e);
+                } else {
+                    throw e;
+                }
+            }
+            break;
+        }
+        conn.commit();
+    }
+
+    public static void main(String[] args) throws ClassNotFoundException, SQLException {
+        // Load the postgres JDBC driver.
+        Class.forName("org.postgresql.Driver");
+
+        // Connect to the "bank" database.
+        Connection db = DriverManager.getConnection("jdbc:postgresql://127.0.0.1:26257/bank?sslmode=disable", "maxroach", "");
+            try {
+                // We need to turn off autocommit mode to allow for
+                // multi-statement transactions.
+                db.setAutoCommit(false);
+                // Perform the transfer. This assumes the table has
+                // already been set up as in the "Build a Test App"
+                // tutorial.
+                RetryableTransaction transfer = transferFunds(1, 2, 100);
+                retryTransaction(db, transfer);
+
+                // Check balances after transfer.
+                db.setAutoCommit(true);
+                ResultSet res = db.createStatement().executeQuery("SELECT id, balance FROM accounts");
+                while (res.next()) {
+                    System.out.printf("\taccount %s: %s\n", res.getInt("id"), res.getInt("balance"));
+                }
+            } catch(InsufficientBalanceException e) {
+                System.out.println("Insufficient balance");
+            } catch(AccountNotFoundException e) {
+                System.out.println("No users in the table with id " + e.account);
+            } catch(AmbiguousCommitException e) {
+                System.out.println("Ambiguous result encountered: " + e);
+            } catch(SQLException e) {
+                System.out.println("SQLException encountered:" + e);
+            } finally {
+                // Close the database connection.
+                db.close();
+            }
+    }
+}

_includes/app/BasicSample.java renamed to _includes/v1.0/app/BasicSample.java

@@ -0,0 +1,45 @@
+require 'active_record'
+require 'pg'
+require 'activerecord-cockroachdb-adapter'
+
+# Connect to CockroachDB through ActiveRecord.
+# In Rails, this configuration would go in config/database.yml as usual.
+ActiveRecord::Base.establish_connection(
+  adapter:  'cockroachdb',
+  username: 'maxroach',
+  password: '',
+  database: 'bank',
+  host:     'localhost',
+  port:     26257,
+)
+
+
+# Define the Account model.
+# In Rails, this would go in app/models/ as usual.
+class Account < ActiveRecord::Base
+  validates :id, presence: true
+  validates :balance, presence: true
+end
+
+# Define a migration for the accounts table.
+# In Rails, this would go in db/migrate/ as usual.
+class Schema < ActiveRecord::Migration
+  def change
+    create_table :accounts, force: true do |t|
+      t.integer :balance
+    end
+  end
+end
+
+# Run the schema migration by hand.
+# In Rails, this would be done via rake db:migrate as usual.
+Schema.new.change()
+
+# Create two accounts, inserting two rows into the accounts table.
+Account.create(id: 1, balance: 1000)
+Account.create(id: 2, balance: 250)
+
+# Retrieve accounts and print out the balances
+Account.all.each do |acct|
+  puts "#{acct.id} #{acct.balance}"
+end

_includes/app/TxnSample.java renamed to _includes/v1.0/app/TxnSample.java

@@ -0,0 +1,31 @@
+(ns test.test
+  (:require [clojure.java.jdbc :as j]
+            [test.util :as util]))
+
+;; Define the connection parameters to the cluster.
+(def db-spec {:subprotocol "postgresql"
+              :subname "//localhost:26257/bank"
+              :user "maxroach"
+              :password ""})
+
+(defn test-basic []
+  ;; Connect to the cluster and run the code below with
+  ;; the connection object bound to 'conn'.
+  (j/with-db-connection [conn db-spec]
+
+    ;; Insert two rows into the "accounts" table.
+    (j/insert! conn :accounts {:id 1 :balance 1000})
+    (j/insert! conn :accounts {:id 2 :balance 250})
+
+    ;; Print out the balances.
+    (println "Initial balances:")
+    (->> (j/query conn ["SELECT id, balance FROM accounts"])
+         (map println)
+         doall)
+
+    ;; The database connection is automatically closed by with-db-connection.
+    ))
+
+
+(defn -main [& args]
+  (test-basic))

_includes/app/activerecord-basic-sample.rb renamed to _includes/v1.0/app/activerecord-basic-sample.rb

@@ -0,0 +1,41 @@
+// Build with g++ -std=c++11 basic-sample.cpp -lpq -lpqxx
+
+#include <cassert>
+#include <functional>
+#include <iostream>
+#include <stdexcept>
+#include <string>
+#include <pqxx/pqxx>
+
+using namespace std;
+
+int main() {
+  try {
+    // Connect to the "bank" database.
+    pqxx::connection c("postgresql://maxroach@localhost:26257/bank");
+
+    pqxx::nontransaction w(c);
+
+    // Create the "accounts" table.
+    w.exec("CREATE TABLE IF NOT EXISTS accounts (id INT PRIMARY KEY, balance INT)");
+
+    // Insert two rows into the "accounts" table.
+    w.exec("INSERT INTO accounts (id, balance) VALUES (1, 1000), (2, 250)");
+
+    // Print out the balances.
+    cout << "Initial balances:" << endl;
+    pqxx::result r = w.exec("SELECT id, balance FROM accounts");
+    for (auto row : r) {
+      cout << row[0].as<int>() << ' ' << row[1].as<int>() << endl;
+    }
+
+    w.commit();  // Note this doesn't doesn't do anything
+                 // for a nontransaction, but is still required.
+  }
+  catch (const exception &e) {
+    cerr << e.what() << endl;
+    return 1;
+  }
+  cout << "Success" << endl;
+  return 0;
+}

_includes/app/basic-sample.c renamed to _includes/v1.0/app/basic-sample.c

@@ -0,0 +1,49 @@
+using System;
+using System.Data;
+using Npgsql;
+
+namespace Cockroach
+{
+  class MainClass
+  {
+    static void Main(string[] args)
+    {
+      var connStringBuilder = new NpgsqlConnectionStringBuilder();
+      connStringBuilder.Host = "localhost";
+      connStringBuilder.Port = 26257;
+      connStringBuilder.Username = "maxroach";
+      connStringBuilder.Database = "bank";
+      Simple(connStringBuilder.ConnectionString);
+    }
+
+    static void Simple(string connString)
+    {
+      using(var conn = new NpgsqlConnection(connString))
+      {
+        conn.Open();
+
+        // Create the "accounts" table.
+        new NpgsqlCommand("CREATE TABLE IF NOT EXISTS accounts (id INT PRIMARY KEY, balance INT)", conn).ExecuteNonQuery();
+
+        // Insert two rows into the "accounts" table.
+        using(var cmd = new NpgsqlCommand())
+        {
+          cmd.Connection = conn;
+          cmd.CommandText = "UPSERT INTO accounts(id, balance) VALUES(@id1, @val1), (@id2, @val2)";
+          cmd.Parameters.AddWithValue("id1", 1);
+          cmd.Parameters.AddWithValue("val1", 1000);
+          cmd.Parameters.AddWithValue("id2", 2);
+          cmd.Parameters.AddWithValue("val2", 250);
+          cmd.ExecuteNonQuery();
+        }
+
+        // Print out the balances.
+        System.Console.WriteLine("Initial balances:");
+        using(var cmd = new NpgsqlCommand("SELECT id, balance FROM accounts", conn))
+        using(var reader = cmd.ExecuteReader())
+        while (reader.Read())
+          Console.Write("\taccount {0}: {1}\n", reader.GetString(0), reader.GetString(1));
+      }
+    }
+  }
+}