Merge lp:~mmcm/akiban-server/construct-hkey-positions into lp:~akiban-technologies/akiban-server/trunk

[Mike McMahon]

Fix construction of partially cascading hkeys.

The problem was that the IndexToHKey map was only built when first used. But a running index into the hkey was not initialized at that time. It was therefore wrong in the case where some earlier hkey positions came from the row and a later one from a parent, as in the partial cascading case in the bug report and the new IT.

[Nathan Williams (nwilliams)]

I think all of the fans of lazy evaluation in the AIS may be gone. Removal thoughts?

Looks good.

review: Approve

=== modified file 'src/main/java/com/akiban/server/store/AbstractStore.java'
--- src/main/java/com/akiban/server/store/AbstractStore.java	2013-07-27 00:43:54 +0000
+++ src/main/java/com/akiban/server/store/AbstractStore.java	2013-08-06 20:16:26 +0000
@@ -212,6 +212,7 @@
                         indexToHKey = parentPkIndex.indexToHKey();
                         parentStoreData = createStoreData(session, parentPkIndex.indexDef());
                         parentPKIndexRow = readIndexRow(session, parentPkIndex, parentStoreData, rowDef, rowData);
+                        i2hPosition = hKeyColumn.positionInHKey();
                     }
                     if(indexToHKey.isOrdinal(i2hPosition)) {
                         assert indexToHKey.getOrdinal(i2hPosition) == segmentRowDef.userTable().getOrdinal() : hKeyColumn;

=== added directory 'src/test/java/com/akiban/server/test/it/bugs/bug1208930'
=== added file 'src/test/java/com/akiban/server/test/it/bugs/bug1208930/PartialCascadeHKeyIT.java'
--- src/test/java/com/akiban/server/test/it/bugs/bug1208930/PartialCascadeHKeyIT.java	1970-01-01 00:00:00 +0000
+++ src/test/java/com/akiban/server/test/it/bugs/bug1208930/PartialCascadeHKeyIT.java	2013-08-06 20:16:26 +0000
@@ -0,0 +1,121 @@
+/**
+ * Copyright (C) 2009-2013 Akiban Technologies, Inc.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.akiban.server.test.it.bug1208930;
+
+import com.akiban.ais.model.Group;
+import com.akiban.qp.operator.API;
+import com.akiban.qp.operator.Operator;
+import com.akiban.qp.row.RowBase;
+import com.akiban.qp.rowtype.UserTableRowType;
+import com.akiban.server.api.dml.scan.NewRow;
+import com.akiban.server.test.it.qp.OperatorITBase;
+
+import org.junit.Test;
+
+public class PartialCascadeHKeyIT extends OperatorITBase
+{
+    @Override
+    protected void setupCreateSchema()
+    {
+        w = createTable(
+            "s", "w",
+            "wid INT NOT NULL",
+            "PRIMARY KEY(wid)");
+        d = createTable(
+            "s", "d",
+            "wid INT NOT NULL",
+            "did INT NOT NULL",
+            "PRIMARY KEY(wid, did)",
+            "GROUPING FOREIGN KEY(wid) REFERENCES w(wid)");
+        c = createTable(
+            "s", "c",
+            "wid INT NOT NULL", 
+            "did INT NOT NULL",
+            "cid INT NOT NULL", 
+            "PRIMARY KEY(wid, did, cid)", 
+            "GROUPING FOREIGN KEY(wid, did) REFERENCES d(wid, did)");
+        o = createTable(
+            "s", "o",
+            "wid INT NOT NULL",
+            "did INT NOT NULL",
+            "cid INT NOT NULL",
+            "oid INT NOT NULL",
+            "PRIMARY KEY(wid, did, oid)",
+            "GROUPING FOREIGN KEY(wid, did, cid) REFERENCES c(wid, did, cid)");
+        i = createTable(
+            "s", "i",
+            "wid INT NOT NULL",
+            "did INT NOT NULL",
+            "oid INT NOT NULL",
+            "iid INT NOT NULL",
+            "PRIMARY KEY(wid, did, iid)",
+            "GROUPING FOREIGN KEY(wid, did, oid) REFERENCES o(wid, did, oid)");
+    }
+
+    @Override
+    protected void setupPostCreateSchema()
+    {
+        schema = new com.akiban.qp.rowtype.Schema(ais());
+        wRowType = schema.userTableRowType(userTable(w));
+        dRowType = schema.userTableRowType(userTable(d));
+        cRowType = schema.userTableRowType(userTable(c));
+        oRowType = schema.userTableRowType(userTable(o));
+        iRowType = schema.userTableRowType(userTable(i));
+        wOrdinal = ddl().getTable(session(), w).getOrdinal();
+        dOrdinal = ddl().getTable(session(), d).getOrdinal();
+        cOrdinal = ddl().getTable(session(), c).getOrdinal();
+        oOrdinal = ddl().getTable(session(), o).getOrdinal();
+        iOrdinal = ddl().getTable(session(), i).getOrdinal();
+        group = group(c);
+        adapter = newStoreAdapter(schema);
+        queryContext = queryContext(adapter);
+        queryBindings = queryContext.createBindings();
+        loadDatabase();
+    }
+
+    private void loadDatabase()
+    {
+        db = new NewRow[] {
+            createNewRow(w, 1L),
+            createNewRow(d, 1L, 11L),
+            createNewRow(c, 1L, 11L, 111L),
+            createNewRow(o, 1L, 11L, 111L, 1111L),
+            createNewRow(i, 1L, 11L, 1111L, 11111L),
+        };
+        use(db);
+    }
+
+    @Test
+    public void testHKeys()
+    {
+        Operator plan = API.groupScan_Default(group);
+        RowBase[] expected = new RowBase[] {
+            row("{1,(long)1}", wRowType, 1L),
+            row("{1,(long)1,2,(long)11}", dRowType, 1L, 11L),
+            row("{1,(long)1,2,(long)11,3,(long)111}", cRowType, 1L, 11L, 111L),
+            row("{1,(long)1,2,(long)11,3,(long)111,4,(long)1111}", oRowType, 1L, 11L, 111L, 1111L),
+            row("{1,(long)1,2,(long)11,3,(long)111,4,(long)1111,5,(long)11111}", iRowType, 1L, 11L, 1111L, 11111L),
+        };
+        compareRows(expected, API.cursor(plan, queryContext, queryBindings));
+    }
+
+    private int w, d, c, o, i;
+    private UserTableRowType wRowType, dRowType, cRowType, oRowType, iRowType;
+    private Group group;
+    private int wOrdinal, dOrdinal, cOrdinal, oOrdinal, iOrdinal;
+}