Akiban Server

SQLAlchemy-AkibanSQLAlchemy-Akiban provides a SQLAlchemy dialect for Akiban, as well asa Core/ORM extension library allowing direct control of Akiban nestedSELECT statements and result sets.RequirementsSQLAlchemy-Akiban depends on:Akiban for Python - thisis an extension for the psycopg2 DBAPI, in order to provide nested result support.SQLAlchemy 0.8 - The dialect has been developed against SQLAlchemy 0.8, whichhas one small API change to support nested result sets. Less criticallyit also supports generation of a WHERE clause using an ORM relationshipattribute (see the example in ORM->Explicit Nesting).ConnectingConnect format is similar to that of a regular Postgresql database:from sqlalchemy import create_engineengine = create_engine("akiban+psycopg2://@localhost:15432/")The Engine above will produce connections when the Engine.connectmethod is called.Nested Result SetsThe dialect introduces a new type called NestedResult, the value ofwhich is a new SQLAlchemy ResultProxy representing a nested result:with engine.begin() as conn: result = conn.execute( "SELECT customer.id, " "(SELECT order.id, order.data " "FROM order " "WHERE customer_id=customer.id) AS order " "FROM customer") for row in result: print "customer id:", row['id'] for order_row in row['order']: print "order id:", order_row['id'] print "order data:", order_row['data']DDL IntegrationCurrently, Akiban requires the GROUPING keyword on all foreign keys. The dialectadds this keyword when emitting DDL for foreign keys:from sqlalchemy import MetaData, Table, Column, String, Integer, ForeignKeymetadata = MetaData()customer = Table('customer', metadata, Column('id', Integer, primary_key=True), Column('name', String(20)),)order = Table('order', metadata, Column('id', Integer, primary_key=True), Column('customer_id', Integer, ForeignKey('customer.id')), Column('order_info', String(20)),)metadata.create_all(conn)Will emit DDL like:CREATE TABLE customer ( id INTEGER NOT NULL GENERATED BY DEFAULT AS IDENTITY, name VARCHAR(20) NULL, PRIMARY KEY (id))CREATE TABLE "order" ( id INTEGER NOT NULL GENERATED BY DEFAULT AS IDENTITY, customer_id INTEGER NULL, order_info VARCHAR(20) NULL, PRIMARY KEY (id), GROUPING FOREIGN KEY(customer_id) REFERENCES customer (id))Nested Select ConstructsMoving up a level, the dialect introduces a new Core construct nestedwhich is an extension of SQLAlchemy's "scalar select" construct. This construct isa drop-in replacement for a standard select() subquery, and is a markerintercepted by the Akiban dialect indicating that column and typing information abouta "nested result" should be carried over from statement to result set:from sqlalchemy import selectfrom sqlalchemy_akiban import nestedsub_stmt = nested([order]).where(order.c.customer_id == customer.c.id).label('o')stmt = select([sub_stmt]).where(customer.c.id == 1)result = conn.execute(stmt)The above will produce SQL like the following:SELECT (SELECT "order".id, "order".customer_id,

Be powerful too. So can “aspirational” needs, such as nice clothing; a person aspires to fit into a certain sphere, so they’re willing to buy the clothes regardless of other factors.Don’t just aim for “faster, better, cheaper.” That typically represents just an incremental change, and it will only be a matter of time before another company does it faster, better or cheaper than can do it. Instead, aim for breakthrough changes, Skok said — pointing to Akiban as an example. The Boston database technology company has developed an entirely different way to organize data than previously available, one which allows for much faster accessing of data and no re-writing of applications, Skok said. “Akiban is a discontinuous innovation in the database world,” he said.If you’re going to pick a fight, pick a big fight. It’s often just as much effort to go after a small fight as a big one.Disruptive innovation shouldn’t have disruptive adoption. If it’s too hard to adopt an innovation, it may never happen. In the case of databases, most new technologies require application re-writes to take advantage of the technologies, which makes them difficult to adopt, said Akiban CEO David McFarlane.Pursue something you believe in. The best value propositions are developed by people who are uniquely suited to tackle the problem. Skok said he’s seen unlikely people find great business success through their passion for the work.Original article here.

"order".order_info FROM "order" WHERE "order".customer_id = customer.id) AS oFROM customer WHERE customer.id = %(id_1)sWithin the result set, nested columns will be targetable not just by column name butalso by column object, and any SQLAlchemy-side type converters in place will take effect for thesecolumns:for row in result: print "customer id:", row[customer.c.id] for order_row in row['order']: print "order id:", order_row[order.c.id] print "order data:", order_row[order.c.data]ORM IntegrationSQLAlchemy-Akiban includes ORM extensions, importable from the sqlalchemy_akiban.orm package.Nested Eager LoadingThe orm.nestedload() and orm.nestedload_all() provide relationship eager loadingmaking usage of an embedded nested result. These are used just like SQLAlchemy's ownorm.joinedload() and orm.subqueryload() functions:from sqlalchemy.orm import relationship, Sessionfrom sqlalchemy.ext.declarative import declarative_basefrom sqlalchemy_akiban import ormBase = declarative_base()class Customer(Base): __table__ = customer orders = relationship("Order")class Order(Base): __table__ = ordersess = Session(engine)for customer in sess.query(Customer).options(orm.nestedload(Customer.orders)): print "customer:", customer.name print "orders:", customer.ordersExplicit NestingThe orm.orm_nested() function acts just like the core nested() construct,except that it is ORM-aware and accepts a Query object; it will invokeQuery style loading, nested into the tuples returned by Query:sess = Session()n = orm.orm_nested(sess.query(Order.id, Order).filter(Customer.orders))q = sess.query(Customer, n).filter(Customer.id == 1)for customer, orders in q: print "customer:", customer.name print "orders:", ordersAbove, we're taking advantage of a new convenience feature in SQLAlchemy 0.8, which is thatwe can pass the Customer.orders class-level attribute directly to Query.filter()in order to generate a correlated WHERE clause. Alternatively, we could just spell this out:query.filter(Customer.id==Order.customer_id)