feat: add samples

samples/autocommit.py

@@ -0,0 +1,44 @@
+# Copyright 2021 Google LLC
+#
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file or at
+# https://developers.google.com/open-source/licenses/bsd
+
+import argparse
+
+from sqlalchemy import create_engine
+
+
+def enable_autocommit_mode(url):
+    """Enables autocommit mode."""
+    # [START sqlalchemy_spanner_autocmmit_on]
+
+    conn = create_engine(url).connect()
+    level = conn.get_isolation_level()
+
+    print("Connection autocommit default mode is {}".format(level))
+    print("Spanner DBAPI default autocommit mode is {}".format(conn.connection.connection.autocommit))
+
+    conn.execution_options(isolation_level="AUTOCOMMIT")
+    print("Connection autocommit mode is {}".format(level))
+    print("Spanner DBAPI autocommit mode is {}".format(conn.connection.connection.autocommit))
+
+    # [END sqlalchemy_spanner_autocmmit_on]
+    return conn
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description=__doc__,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument("url", help="Your Cloud Spanner url which contains "
+                                    "project-id, instance-id, databas-id.")
+
+    subparsers = parser.add_subparsers(dest="command")
+    subparsers.add_parser("enable_autocommit_mode", help=enable_autocommit_mode.__doc__)
+    args = parser.parse_args()
+    if args.command == "enable_autocommit_mode":
+        enable_autocommit_mode(args.url)
+    else:
+        print(f"Command {args.command} did not match expected commands.")

samples/create_table.py

@@ -0,0 +1,57 @@
+# Copyright 2021 Google LLC
+#
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file or at
+# https://developers.google.com/open-source/licenses/bsd
+
+import argparse
+
+from sqlalchemy import (
+        Column,
+        Integer,
+        MetaData,
+        String,
+        Table,
+        create_engine,
+)
+
+
+def create_table(url, random_table_id):
+    """Create the table"""
+    # [START sqlalchemy_spanner_create_table]
+
+    engine = create_engine(url)
+    metadata = MetaData(bind=engine)
+
+    table = Table(
+        random_table_id,
+        metadata,
+        Column("user_id", Integer, primary_key=True),
+        Column("user_name", String(16), nullable=False),
+    )
+    table.create()
+
+    print("Table {} is created successfully".format(table.name))
+    # [END sqlalchemy_spanner_create_table]
+    return table
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description=__doc__,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument("url", help="Your Cloud Spanner url which contains "
+                                    "project-id, instance-id, databas-id.")
+    parser.add_argument(
+        "--table-id",
+        help="Your Cloud Spanner table ID.",
+        default="example_table",
+    )
+    subparsers = parser.add_subparsers(dest="command")
+    subparsers.add_parser("create_table", help=create_table.__doc__)
+    args = parser.parse_args()
+    if args.command == "create_table":
+        create_table(args.url, args.table-id)
+    else:
+        print(f"Command {args.command} did not match expected commands.")

samples/drop_table.py

@@ -0,0 +1,60 @@
+# Copyright 2021 Google LLC
+#
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file or at
+# https://developers.google.com/open-source/licenses/bsd
+
+import argparse
+
+from sqlalchemy import (
+        Column,
+        Integer,
+        MetaData,
+        String,
+        Table,
+        create_engine,
+)
+
+
+def drop_table(url, random_table_id):
+    """Drop the table"""
+    # [START sqlalchemy_spanner_drop_table]
+
+    engine = create_engine(url)
+    metadata = MetaData(bind=engine)
+
+    table = Table(
+        random_table_id,
+        metadata,
+        Column("user_id", Integer, primary_key=True),
+        Column("user_name", String(16), nullable=False),
+    )
+
+    table.create()
+
+    table.drop()
+    print("Table {} is dropped successfully".format(table.name))
+    # [END sqlalchemy_spanner_drop_table]
+    return table
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description=__doc__,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument("url", help="Your Cloud Spanner url which contains "
+                                    "project-id, instance-id, databas-id.")
+    parser.add_argument(
+        "--table-id",
+        help="Your Cloud Spanner table ID.",
+        default="example_table",
+    )
+    subparsers = parser.add_subparsers(dest="command")
+    subparsers.add_parser("drop_table", help=drop_table.__doc__)
+    args = parser.parse_args()
+    if args.command == "drop_table":
+        drop_table(args.url, args.table-id)
+    else:
+        print(f"Command {args.command} did not match expected commands.")
+

samples/table_delete_all_rows.py

@@ -0,0 +1,54 @@
+# Copyright 2021 Google LLC
+#
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file or at
+# https://developers.google.com/open-source/licenses/bsd
+
+import argparse
+
+
+def delete_all_rows(table):
+    """Delete all rows from the table"""
+
+    # TODO(developer): Create the table
+    # table = Table(
+    #    table_id,
+    #    metadata,
+    #    Column("user_id", Integer, primary_key=True),
+    #    Column("user_name", String(16), nullable=False),
+    # )
+    # table.create()
+
+    table.insert().execute(
+        {"user_id": 1, "user_name": 'ABC'},
+        {"user_id": 2, "user_name": 'DEF'}
+    )
+
+    result = table.select().execute().fetchall()
+    print("Total inserted rows:", len(result))
+
+    # [START sqlalchemy_spanner_delete_all_rows]
+    table.delete().execute()
+
+    result = table.select().execute().fetchall()
+    print("Total rows:", len(result))
+    # [END sqlalchemy_spanner_delete_all_rows]
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description=__doc__,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+
+    parser.add_argument(
+        "--table",
+        help="Your sqlalchemy table object.",
+    )
+    subparsers = parser.add_subparsers(dest="command")
+    subparsers.add_parser("delete_all_rows", help=delete_all_rows.__doc__)
+    args = parser.parse_args()
+    if args.command == "delete_all_rows":
+        delete_all_rows(args.table)
+    else:
+        print(f"Command {args.command} did not match expected commands.")

samples/table_delete_row_with_where_condition.py

@@ -0,0 +1,54 @@
+# Copyright 2021 Google LLC
+#
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file or at
+# https://developers.google.com/open-source/licenses/bsd
+
+import argparse
+
+
+def delete_row_with_where_condition(table):
+    """Delete selected row from the table"""
+
+    # TODO(developer): Create the table
+    # table = Table(
+    #    table_id,
+    #    metadata,
+    #    Column("user_id", Integer, primary_key=True),
+    #    Column("user_name", String(16), nullable=False),
+    # )
+    # table.create()
+
+    table.insert().execute(
+        {"user_id": 1, "user_name": 'ABC'},
+        {"user_id": 2, "user_name": 'DEF'}
+    )
+
+    result = table.select().execute().fetchall()
+    print("Total inserted rows:", len(result))
+
+    # [START sqlalchemy_spanner_delete_row_with_where_condition]
+    table.delete().where(table.c.user_id == 1).execute()
+
+    result = table.select().execute().fetchall()
+    print("Total rows:", len(result))
+    # [END sqlalchemy_spanner_delete_row_with_where_condition]
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description=__doc__,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+
+    parser.add_argument(
+        "--table",
+        help="Your sqlalchemy table object.",
+    )
+    subparsers = parser.add_subparsers(dest="command")
+    subparsers.add_parser("delete_row_with_where_condition", help=delete_row_with_where_condition.__doc__)
+    args = parser.parse_args()
+    if args.command == "delete_row_with_where_condition":
+        delete_row_with_where_condition(args.table)
+    else:
+        print(f"Command {args.command} did not match expected commands.")

samples/table_exists.py

@@ -0,0 +1,44 @@
+# Copyright 2021 Google LLC
+#
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file or at
+# https://developers.google.com/open-source/licenses/bsd
+
+import argparse
+
+
+def table_exists(table):
+    """Check the table exists"""
+    # [START sqlalchemy_spanner_table_exists]
+
+    # TODO(developer): Create the table
+    # table = Table(
+    #    table_id,
+    #    metadata,
+    #    Column("user_id", Integer, primary_key=True),
+    #    Column("user_name", String(16), nullable=False),
+    # )
+    # table.create()
+
+    result = table.exists()
+    print("Table exists:", result)
+    # [END sqlalchemy_spanner_table_exists]
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description=__doc__,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+
+    parser.add_argument(
+        "--table",
+        help="Your sqlalchemy table object.",
+    )
+    subparsers = parser.add_subparsers(dest="command")
+    subparsers.add_parser("table_exists", help=table_exists.__doc__)
+    args = parser.parse_args()
+    if args.command == "table_exists":
+        table_exists(args.table)
+    else:
+        print(f"Command {args.command} did not match expected commands.")

samples/table_fetch_row_with_where_condition.py

@@ -0,0 +1,51 @@
+# Copyright 2021 Google LLC
+#
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file or at
+# https://developers.google.com/open-source/licenses/bsd
+
+import argparse
+
+
+def fetch_row_with_where_condition(table):
+    """Fetch row with where condition from the table"""
+
+    # TODO(developer): Create the table
+    # table = Table(
+    #    table_id,
+    #    metadata,
+    #    Column("user_id", Integer, primary_key=True),
+    #    Column("user_name", String(16), nullable=False),
+    # )
+    # table.create()
+
+    table.insert().execute([
+        {"user_id": 1, "user_name": 'ABC'},
+        {"user_id": 2, "user_name": 'DEF'}
+    ])
+
+    # [START sqlalchemy_spanner_fetch_row_with_where_condition]
+    result = list(table.select().where(table.c.user_id == 1).execute())
+
+    print("Output is :", result)
+    # [END sqlalchemy_spanner_fetch_row_with_where_condition]
+    return result
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description=__doc__,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+
+    parser.add_argument(
+        "--table",
+        help="Your sqlalchemy table object.",
+    )
+    subparsers = parser.add_subparsers(dest="command")
+    subparsers.add_parser("fetch_row_with_where_condition", help=fetch_row_with_where_condition.__doc__)
+    args = parser.parse_args()
+    if args.command == "fetch_row_with_where_condition":
+        fetch_row_with_where_condition(args.table)
+    else:
+        print(f"Command {args.command} did not match expected commands.")