Return-Path: X-Original-To: apmail-cassandra-commits-archive@www.apache.org Delivered-To: apmail-cassandra-commits-archive@www.apache.org Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by minotaur.apache.org (Postfix) with SMTP id 0E2D2774C for ; Tue, 6 Sep 2011 16:22:05 +0000 (UTC) Received: (qmail 78825 invoked by uid 500); 6 Sep 2011 16:22:04 -0000 Delivered-To: apmail-cassandra-commits-archive@cassandra.apache.org Received: (qmail 78782 invoked by uid 500); 6 Sep 2011 16:22:04 -0000 Mailing-List: contact commits-help@cassandra.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: dev@cassandra.apache.org Delivered-To: mailing list commits@cassandra.apache.org Received: (qmail 78670 invoked by uid 99); 6 Sep 2011 16:22:04 -0000 Received: from nike.apache.org (HELO nike.apache.org) (192.87.106.230) by apache.org (qpsmtpd/0.29) with ESMTP; Tue, 06 Sep 2011 16:22:04 +0000 X-ASF-Spam-Status: No, hits=-2000.0 required=5.0 tests=ALL_TRUSTED X-Spam-Check-By: apache.org Received: from [140.211.11.4] (HELO eris.apache.org) (140.211.11.4) by apache.org (qpsmtpd/0.29) with ESMTP; Tue, 06 Sep 2011 16:21:54 +0000 Received: from eris.apache.org (localhost [127.0.0.1]) by eris.apache.org (Postfix) with ESMTP id F2CEA23889B3 for ; Tue, 6 Sep 2011 16:21:31 +0000 (UTC) Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Subject: svn commit: r1165750 [2/2] - in /cassandra/trunk: drivers/java/src/org/apache/cassandra/cql/jdbc/ drivers/java/test/org/apache/cassandra/cql/ drivers/py/cql/ drivers/py/cql/cassandra/ interface/ interface/thrift/gen-java/org/apache/cassandra/thrift/ sr... Date: Tue, 06 Sep 2011 16:21:30 -0000 To: commits@cassandra.apache.org From: jbellis@apache.org X-Mailer: svnmailer-1.0.8 Message-Id: <20110906162131.F2CEA23889B3@eris.apache.org> X-Virus-Checked: Checked by ClamAV on apache.org Modified: cassandra/trunk/interface/thrift/gen-java/org/apache/cassandra/thrift/Cassandra.java URL: http://svn.apache.org/viewvc/cassandra/trunk/interface/thrift/gen-java/org/apache/cassandra/thrift/Cassandra.java?rev=1165750&r1=1165749&r2=1165750&view=diff ============================================================================== --- cassandra/trunk/interface/thrift/gen-java/org/apache/cassandra/thrift/Cassandra.java (original) +++ cassandra/trunk/interface/thrift/gen-java/org/apache/cassandra/thrift/Cassandra.java Tue Sep 6 16:21:29 2011 @@ -7736,14 +7736,14 @@ public class Cassandra { case 0: // SUCCESS if (field.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list65 = iprot.readListBegin(); - this.success = new ArrayList(_list65.size); - for (int _i66 = 0; _i66 < _list65.size; ++_i66) + org.apache.thrift.protocol.TList _list75 = iprot.readListBegin(); + this.success = new ArrayList(_list75.size); + for (int _i76 = 0; _i76 < _list75.size; ++_i76) { - ColumnOrSuperColumn _elem67; - _elem67 = new ColumnOrSuperColumn(); - _elem67.read(iprot); - this.success.add(_elem67); + ColumnOrSuperColumn _elem77; + _elem77 = new ColumnOrSuperColumn(); + _elem77.read(iprot); + this.success.add(_elem77); } iprot.readListEnd(); } @@ -7793,9 +7793,9 @@ public class Cassandra { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size())); - for (ColumnOrSuperColumn _iter68 : this.success) + for (ColumnOrSuperColumn _iter78 : this.success) { - _iter68.write(oprot); + _iter78.write(oprot); } oprot.writeListEnd(); } @@ -9595,13 +9595,13 @@ public class Cassandra { case 1: // KEYS if (field.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list69 = iprot.readListBegin(); - this.keys = new ArrayList(_list69.size); - for (int _i70 = 0; _i70 < _list69.size; ++_i70) + org.apache.thrift.protocol.TList _list79 = iprot.readListBegin(); + this.keys = new ArrayList(_list79.size); + for (int _i80 = 0; _i80 < _list79.size; ++_i80) { - ByteBuffer _elem71; - _elem71 = iprot.readBinary(); - this.keys.add(_elem71); + ByteBuffer _elem81; + _elem81 = iprot.readBinary(); + this.keys.add(_elem81); } iprot.readListEnd(); } @@ -9651,9 +9651,9 @@ public class Cassandra { oprot.writeFieldBegin(KEYS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.keys.size())); - for (ByteBuffer _iter72 : this.keys) + for (ByteBuffer _iter82 : this.keys) { - oprot.writeBinary(_iter72); + oprot.writeBinary(_iter82); } oprot.writeListEnd(); } @@ -10242,26 +10242,26 @@ public class Cassandra { case 0: // SUCCESS if (field.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map73 = iprot.readMapBegin(); - this.success = new HashMap>(2*_map73.size); - for (int _i74 = 0; _i74 < _map73.size; ++_i74) + org.apache.thrift.protocol.TMap _map83 = iprot.readMapBegin(); + this.success = new HashMap>(2*_map83.size); + for (int _i84 = 0; _i84 < _map83.size; ++_i84) { - ByteBuffer _key75; - List _val76; - _key75 = iprot.readBinary(); + ByteBuffer _key85; + List _val86; + _key85 = iprot.readBinary(); { - org.apache.thrift.protocol.TList _list77 = iprot.readListBegin(); - _val76 = new ArrayList(_list77.size); - for (int _i78 = 0; _i78 < _list77.size; ++_i78) + org.apache.thrift.protocol.TList _list87 = iprot.readListBegin(); + _val86 = new ArrayList(_list87.size); + for (int _i88 = 0; _i88 < _list87.size; ++_i88) { - ColumnOrSuperColumn _elem79; - _elem79 = new ColumnOrSuperColumn(); - _elem79.read(iprot); - _val76.add(_elem79); + ColumnOrSuperColumn _elem89; + _elem89 = new ColumnOrSuperColumn(); + _elem89.read(iprot); + _val86.add(_elem89); } iprot.readListEnd(); } - this.success.put(_key75, _val76); + this.success.put(_key85, _val86); } iprot.readMapEnd(); } @@ -10311,14 +10311,14 @@ public class Cassandra { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.LIST, this.success.size())); - for (Map.Entry> _iter80 : this.success.entrySet()) + for (Map.Entry> _iter90 : this.success.entrySet()) { - oprot.writeBinary(_iter80.getKey()); + oprot.writeBinary(_iter90.getKey()); { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, _iter80.getValue().size())); - for (ColumnOrSuperColumn _iter81 : _iter80.getValue()) + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, _iter90.getValue().size())); + for (ColumnOrSuperColumn _iter91 : _iter90.getValue()) { - _iter81.write(oprot); + _iter91.write(oprot); } oprot.writeListEnd(); } @@ -10906,13 +10906,13 @@ public class Cassandra { case 1: // KEYS if (field.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list82 = iprot.readListBegin(); - this.keys = new ArrayList(_list82.size); - for (int _i83 = 0; _i83 < _list82.size; ++_i83) + org.apache.thrift.protocol.TList _list92 = iprot.readListBegin(); + this.keys = new ArrayList(_list92.size); + for (int _i93 = 0; _i93 < _list92.size; ++_i93) { - ByteBuffer _elem84; - _elem84 = iprot.readBinary(); - this.keys.add(_elem84); + ByteBuffer _elem94; + _elem94 = iprot.readBinary(); + this.keys.add(_elem94); } iprot.readListEnd(); } @@ -10962,9 +10962,9 @@ public class Cassandra { oprot.writeFieldBegin(KEYS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.keys.size())); - for (ByteBuffer _iter85 : this.keys) + for (ByteBuffer _iter95 : this.keys) { - oprot.writeBinary(_iter85); + oprot.writeBinary(_iter95); } oprot.writeListEnd(); } @@ -11549,15 +11549,15 @@ public class Cassandra { case 0: // SUCCESS if (field.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map86 = iprot.readMapBegin(); - this.success = new HashMap(2*_map86.size); - for (int _i87 = 0; _i87 < _map86.size; ++_i87) + org.apache.thrift.protocol.TMap _map96 = iprot.readMapBegin(); + this.success = new HashMap(2*_map96.size); + for (int _i97 = 0; _i97 < _map96.size; ++_i97) { - ByteBuffer _key88; - int _val89; - _key88 = iprot.readBinary(); - _val89 = iprot.readI32(); - this.success.put(_key88, _val89); + ByteBuffer _key98; + int _val99; + _key98 = iprot.readBinary(); + _val99 = iprot.readI32(); + this.success.put(_key98, _val99); } iprot.readMapEnd(); } @@ -11607,10 +11607,10 @@ public class Cassandra { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.I32, this.success.size())); - for (Map.Entry _iter90 : this.success.entrySet()) + for (Map.Entry _iter100 : this.success.entrySet()) { - oprot.writeBinary(_iter90.getKey()); - oprot.writeI32(_iter90.getValue()); + oprot.writeBinary(_iter100.getKey()); + oprot.writeI32(_iter100.getValue()); } oprot.writeMapEnd(); } @@ -12794,14 +12794,14 @@ public class Cassandra { case 0: // SUCCESS if (field.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list91 = iprot.readListBegin(); - this.success = new ArrayList(_list91.size); - for (int _i92 = 0; _i92 < _list91.size; ++_i92) + org.apache.thrift.protocol.TList _list101 = iprot.readListBegin(); + this.success = new ArrayList(_list101.size); + for (int _i102 = 0; _i102 < _list101.size; ++_i102) { - KeySlice _elem93; - _elem93 = new KeySlice(); - _elem93.read(iprot); - this.success.add(_elem93); + KeySlice _elem103; + _elem103 = new KeySlice(); + _elem103.read(iprot); + this.success.add(_elem103); } iprot.readListEnd(); } @@ -12851,9 +12851,9 @@ public class Cassandra { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size())); - for (KeySlice _iter94 : this.success) + for (KeySlice _iter104 : this.success) { - _iter94.write(oprot); + _iter104.write(oprot); } oprot.writeListEnd(); } @@ -14037,14 +14037,14 @@ public class Cassandra { case 0: // SUCCESS if (field.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list95 = iprot.readListBegin(); - this.success = new ArrayList(_list95.size); - for (int _i96 = 0; _i96 < _list95.size; ++_i96) + org.apache.thrift.protocol.TList _list105 = iprot.readListBegin(); + this.success = new ArrayList(_list105.size); + for (int _i106 = 0; _i106 < _list105.size; ++_i106) { - KeySlice _elem97; - _elem97 = new KeySlice(); - _elem97.read(iprot); - this.success.add(_elem97); + KeySlice _elem107; + _elem107 = new KeySlice(); + _elem107.read(iprot); + this.success.add(_elem107); } iprot.readListEnd(); } @@ -14094,9 +14094,9 @@ public class Cassandra { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size())); - for (KeySlice _iter98 : this.success) + for (KeySlice _iter108 : this.success) { - _iter98.write(oprot); + _iter108.write(oprot); } oprot.writeListEnd(); } @@ -17041,6 +17041,8 @@ public class Cassandra { private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { try { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_bit_vector = new BitSet(1); read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); } catch (org.apache.thrift.TException te) { throw new java.io.IOException(te); @@ -18939,38 +18941,38 @@ public class Cassandra { case 1: // MUTATION_MAP if (field.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map99 = iprot.readMapBegin(); - this.mutation_map = new HashMap>>(2*_map99.size); - for (int _i100 = 0; _i100 < _map99.size; ++_i100) + org.apache.thrift.protocol.TMap _map109 = iprot.readMapBegin(); + this.mutation_map = new HashMap>>(2*_map109.size); + for (int _i110 = 0; _i110 < _map109.size; ++_i110) { - ByteBuffer _key101; - Map> _val102; - _key101 = iprot.readBinary(); + ByteBuffer _key111; + Map> _val112; + _key111 = iprot.readBinary(); { - org.apache.thrift.protocol.TMap _map103 = iprot.readMapBegin(); - _val102 = new HashMap>(2*_map103.size); - for (int _i104 = 0; _i104 < _map103.size; ++_i104) + org.apache.thrift.protocol.TMap _map113 = iprot.readMapBegin(); + _val112 = new HashMap>(2*_map113.size); + for (int _i114 = 0; _i114 < _map113.size; ++_i114) { - String _key105; - List _val106; - _key105 = iprot.readString(); + String _key115; + List _val116; + _key115 = iprot.readString(); { - org.apache.thrift.protocol.TList _list107 = iprot.readListBegin(); - _val106 = new ArrayList(_list107.size); - for (int _i108 = 0; _i108 < _list107.size; ++_i108) + org.apache.thrift.protocol.TList _list117 = iprot.readListBegin(); + _val116 = new ArrayList(_list117.size); + for (int _i118 = 0; _i118 < _list117.size; ++_i118) { - Mutation _elem109; - _elem109 = new Mutation(); - _elem109.read(iprot); - _val106.add(_elem109); + Mutation _elem119; + _elem119 = new Mutation(); + _elem119.read(iprot); + _val116.add(_elem119); } iprot.readListEnd(); } - _val102.put(_key105, _val106); + _val112.put(_key115, _val116); } iprot.readMapEnd(); } - this.mutation_map.put(_key101, _val102); + this.mutation_map.put(_key111, _val112); } iprot.readMapEnd(); } @@ -19004,19 +19006,19 @@ public class Cassandra { oprot.writeFieldBegin(MUTATION_MAP_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.MAP, this.mutation_map.size())); - for (Map.Entry>> _iter110 : this.mutation_map.entrySet()) + for (Map.Entry>> _iter120 : this.mutation_map.entrySet()) { - oprot.writeBinary(_iter110.getKey()); + oprot.writeBinary(_iter120.getKey()); { - oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.LIST, _iter110.getValue().size())); - for (Map.Entry> _iter111 : _iter110.getValue().entrySet()) + oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.LIST, _iter120.getValue().size())); + for (Map.Entry> _iter121 : _iter120.getValue().entrySet()) { - oprot.writeString(_iter111.getKey()); + oprot.writeString(_iter121.getKey()); { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, _iter111.getValue().size())); - for (Mutation _iter112 : _iter111.getValue()) + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, _iter121.getValue().size())); + for (Mutation _iter122 : _iter121.getValue()) { - _iter112.write(oprot); + _iter122.write(oprot); } oprot.writeListEnd(); } @@ -20831,25 +20833,25 @@ public class Cassandra { case 0: // SUCCESS if (field.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map113 = iprot.readMapBegin(); - this.success = new HashMap>(2*_map113.size); - for (int _i114 = 0; _i114 < _map113.size; ++_i114) + org.apache.thrift.protocol.TMap _map123 = iprot.readMapBegin(); + this.success = new HashMap>(2*_map123.size); + for (int _i124 = 0; _i124 < _map123.size; ++_i124) { - String _key115; - List _val116; - _key115 = iprot.readString(); + String _key125; + List _val126; + _key125 = iprot.readString(); { - org.apache.thrift.protocol.TList _list117 = iprot.readListBegin(); - _val116 = new ArrayList(_list117.size); - for (int _i118 = 0; _i118 < _list117.size; ++_i118) + org.apache.thrift.protocol.TList _list127 = iprot.readListBegin(); + _val126 = new ArrayList(_list127.size); + for (int _i128 = 0; _i128 < _list127.size; ++_i128) { - String _elem119; - _elem119 = iprot.readString(); - _val116.add(_elem119); + String _elem129; + _elem129 = iprot.readString(); + _val126.add(_elem129); } iprot.readListEnd(); } - this.success.put(_key115, _val116); + this.success.put(_key125, _val126); } iprot.readMapEnd(); } @@ -20883,14 +20885,14 @@ public class Cassandra { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.LIST, this.success.size())); - for (Map.Entry> _iter120 : this.success.entrySet()) + for (Map.Entry> _iter130 : this.success.entrySet()) { - oprot.writeString(_iter120.getKey()); + oprot.writeString(_iter130.getKey()); { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, _iter120.getValue().size())); - for (String _iter121 : _iter120.getValue()) + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, _iter130.getValue().size())); + for (String _iter131 : _iter130.getValue()) { - oprot.writeString(_iter121); + oprot.writeString(_iter131); } oprot.writeListEnd(); } @@ -21489,14 +21491,14 @@ public class Cassandra { case 0: // SUCCESS if (field.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list122 = iprot.readListBegin(); - this.success = new ArrayList(_list122.size); - for (int _i123 = 0; _i123 < _list122.size; ++_i123) + org.apache.thrift.protocol.TList _list132 = iprot.readListBegin(); + this.success = new ArrayList(_list132.size); + for (int _i133 = 0; _i133 < _list132.size; ++_i133) { - KsDef _elem124; - _elem124 = new KsDef(); - _elem124.read(iprot); - this.success.add(_elem124); + KsDef _elem134; + _elem134 = new KsDef(); + _elem134.read(iprot); + this.success.add(_elem134); } iprot.readListEnd(); } @@ -21530,9 +21532,9 @@ public class Cassandra { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size())); - for (KsDef _iter125 : this.success) + for (KsDef _iter135 : this.success) { - _iter125.write(oprot); + _iter135.write(oprot); } oprot.writeListEnd(); } @@ -23245,14 +23247,14 @@ public class Cassandra { case 0: // SUCCESS if (field.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list126 = iprot.readListBegin(); - this.success = new ArrayList(_list126.size); - for (int _i127 = 0; _i127 < _list126.size; ++_i127) + org.apache.thrift.protocol.TList _list136 = iprot.readListBegin(); + this.success = new ArrayList(_list136.size); + for (int _i137 = 0; _i137 < _list136.size; ++_i137) { - TokenRange _elem128; - _elem128 = new TokenRange(); - _elem128.read(iprot); - this.success.add(_elem128); + TokenRange _elem138; + _elem138 = new TokenRange(); + _elem138.read(iprot); + this.success.add(_elem138); } iprot.readListEnd(); } @@ -23286,9 +23288,9 @@ public class Cassandra { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size())); - for (TokenRange _iter129 : this.success) + for (TokenRange _iter139 : this.success) { - _iter129.write(oprot); + _iter139.write(oprot); } oprot.writeListEnd(); } @@ -25750,8 +25752,6 @@ public class Cassandra { private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { try { - // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. - __isset_bit_vector = new BitSet(1); read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); } catch (org.apache.thrift.TException te) { throw new java.io.IOException(te); @@ -26092,13 +26092,13 @@ public class Cassandra { case 0: // SUCCESS if (field.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list130 = iprot.readListBegin(); - this.success = new ArrayList(_list130.size); - for (int _i131 = 0; _i131 < _list130.size; ++_i131) + org.apache.thrift.protocol.TList _list140 = iprot.readListBegin(); + this.success = new ArrayList(_list140.size); + for (int _i141 = 0; _i141 < _list140.size; ++_i141) { - String _elem132; - _elem132 = iprot.readString(); - this.success.add(_elem132); + String _elem142; + _elem142 = iprot.readString(); + this.success.add(_elem142); } iprot.readListEnd(); } @@ -26132,9 +26132,9 @@ public class Cassandra { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.success.size())); - for (String _iter133 : this.success) + for (String _iter143 : this.success) { - oprot.writeString(_iter133); + oprot.writeString(_iter143); } oprot.writeListEnd(); } Modified: cassandra/trunk/interface/thrift/gen-java/org/apache/cassandra/thrift/Constants.java URL: http://svn.apache.org/viewvc/cassandra/trunk/interface/thrift/gen-java/org/apache/cassandra/thrift/Constants.java?rev=1165750&r1=1165749&r2=1165750&view=diff ============================================================================== --- cassandra/trunk/interface/thrift/gen-java/org/apache/cassandra/thrift/Constants.java (original) +++ cassandra/trunk/interface/thrift/gen-java/org/apache/cassandra/thrift/Constants.java Tue Sep 6 16:21:29 2011 @@ -44,6 +44,6 @@ import org.slf4j.LoggerFactory; public class Constants { - public static final String VERSION = "19.12.0"; + public static final String VERSION = "19.13.0"; } Added: cassandra/trunk/interface/thrift/gen-java/org/apache/cassandra/thrift/CqlMetadata.java URL: http://svn.apache.org/viewvc/cassandra/trunk/interface/thrift/gen-java/org/apache/cassandra/thrift/CqlMetadata.java?rev=1165750&view=auto ============================================================================== --- cassandra/trunk/interface/thrift/gen-java/org/apache/cassandra/thrift/CqlMetadata.java (added) +++ cassandra/trunk/interface/thrift/gen-java/org/apache/cassandra/thrift/CqlMetadata.java Tue Sep 6 16:21:29 2011 @@ -0,0 +1,734 @@ +/** + * Autogenerated by Thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + */ +package org.apache.cassandra.thrift; +/* + * + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + * + */ + + +import org.apache.commons.lang.builder.HashCodeBuilder; +import java.util.List; +import java.util.ArrayList; +import java.util.Map; +import java.util.HashMap; +import java.util.EnumMap; +import java.util.Set; +import java.util.HashSet; +import java.util.EnumSet; +import java.util.Collections; +import java.util.BitSet; +import java.nio.ByteBuffer; +import java.util.Arrays; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class CqlMetadata implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("CqlMetadata"); + + private static final org.apache.thrift.protocol.TField NAME_TYPES_FIELD_DESC = new org.apache.thrift.protocol.TField("name_types", org.apache.thrift.protocol.TType.MAP, (short)1); + private static final org.apache.thrift.protocol.TField VALUE_TYPES_FIELD_DESC = new org.apache.thrift.protocol.TField("value_types", org.apache.thrift.protocol.TType.MAP, (short)2); + private static final org.apache.thrift.protocol.TField DEFAULT_NAME_TYPE_FIELD_DESC = new org.apache.thrift.protocol.TField("default_name_type", org.apache.thrift.protocol.TType.STRING, (short)3); + private static final org.apache.thrift.protocol.TField DEFAULT_VALUE_TYPE_FIELD_DESC = new org.apache.thrift.protocol.TField("default_value_type", org.apache.thrift.protocol.TType.STRING, (short)4); + + public Map name_types; + public Map value_types; + public String default_name_type; + public String default_value_type; + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + NAME_TYPES((short)1, "name_types"), + VALUE_TYPES((short)2, "value_types"), + DEFAULT_NAME_TYPE((short)3, "default_name_type"), + DEFAULT_VALUE_TYPE((short)4, "default_value_type"); + + private static final Map byName = new HashMap(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + case 1: // NAME_TYPES + return NAME_TYPES; + case 2: // VALUE_TYPES + return VALUE_TYPES; + case 3: // DEFAULT_NAME_TYPE + return DEFAULT_NAME_TYPE; + case 4: // DEFAULT_VALUE_TYPE + return DEFAULT_VALUE_TYPE; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.NAME_TYPES, new org.apache.thrift.meta_data.FieldMetaData("name_types", org.apache.thrift.TFieldRequirementType.REQUIRED, + new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true), + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)))); + tmpMap.put(_Fields.VALUE_TYPES, new org.apache.thrift.meta_data.FieldMetaData("value_types", org.apache.thrift.TFieldRequirementType.REQUIRED, + new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true), + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)))); + tmpMap.put(_Fields.DEFAULT_NAME_TYPE, new org.apache.thrift.meta_data.FieldMetaData("default_name_type", org.apache.thrift.TFieldRequirementType.REQUIRED, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.DEFAULT_VALUE_TYPE, new org.apache.thrift.meta_data.FieldMetaData("default_value_type", org.apache.thrift.TFieldRequirementType.REQUIRED, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(CqlMetadata.class, metaDataMap); + } + + public CqlMetadata() { + } + + public CqlMetadata( + Map name_types, + Map value_types, + String default_name_type, + String default_value_type) + { + this(); + this.name_types = name_types; + this.value_types = value_types; + this.default_name_type = default_name_type; + this.default_value_type = default_value_type; + } + + /** + * Performs a deep copy on other. + */ + public CqlMetadata(CqlMetadata other) { + if (other.isSetName_types()) { + Map __this__name_types = new HashMap(); + for (Map.Entry other_element : other.name_types.entrySet()) { + + ByteBuffer other_element_key = other_element.getKey(); + String other_element_value = other_element.getValue(); + + ByteBuffer __this__name_types_copy_key = org.apache.thrift.TBaseHelper.copyBinary(other_element_key); +; + + String __this__name_types_copy_value = other_element_value; + + __this__name_types.put(__this__name_types_copy_key, __this__name_types_copy_value); + } + this.name_types = __this__name_types; + } + if (other.isSetValue_types()) { + Map __this__value_types = new HashMap(); + for (Map.Entry other_element : other.value_types.entrySet()) { + + ByteBuffer other_element_key = other_element.getKey(); + String other_element_value = other_element.getValue(); + + ByteBuffer __this__value_types_copy_key = org.apache.thrift.TBaseHelper.copyBinary(other_element_key); +; + + String __this__value_types_copy_value = other_element_value; + + __this__value_types.put(__this__value_types_copy_key, __this__value_types_copy_value); + } + this.value_types = __this__value_types; + } + if (other.isSetDefault_name_type()) { + this.default_name_type = other.default_name_type; + } + if (other.isSetDefault_value_type()) { + this.default_value_type = other.default_value_type; + } + } + + public CqlMetadata deepCopy() { + return new CqlMetadata(this); + } + + @Override + public void clear() { + this.name_types = null; + this.value_types = null; + this.default_name_type = null; + this.default_value_type = null; + } + + public int getName_typesSize() { + return (this.name_types == null) ? 0 : this.name_types.size(); + } + + public void putToName_types(ByteBuffer key, String val) { + if (this.name_types == null) { + this.name_types = new HashMap(); + } + this.name_types.put(key, val); + } + + public Map getName_types() { + return this.name_types; + } + + public CqlMetadata setName_types(Map name_types) { + this.name_types = name_types; + return this; + } + + public void unsetName_types() { + this.name_types = null; + } + + /** Returns true if field name_types is set (has been assigned a value) and false otherwise */ + public boolean isSetName_types() { + return this.name_types != null; + } + + public void setName_typesIsSet(boolean value) { + if (!value) { + this.name_types = null; + } + } + + public int getValue_typesSize() { + return (this.value_types == null) ? 0 : this.value_types.size(); + } + + public void putToValue_types(ByteBuffer key, String val) { + if (this.value_types == null) { + this.value_types = new HashMap(); + } + this.value_types.put(key, val); + } + + public Map getValue_types() { + return this.value_types; + } + + public CqlMetadata setValue_types(Map value_types) { + this.value_types = value_types; + return this; + } + + public void unsetValue_types() { + this.value_types = null; + } + + /** Returns true if field value_types is set (has been assigned a value) and false otherwise */ + public boolean isSetValue_types() { + return this.value_types != null; + } + + public void setValue_typesIsSet(boolean value) { + if (!value) { + this.value_types = null; + } + } + + public String getDefault_name_type() { + return this.default_name_type; + } + + public CqlMetadata setDefault_name_type(String default_name_type) { + this.default_name_type = default_name_type; + return this; + } + + public void unsetDefault_name_type() { + this.default_name_type = null; + } + + /** Returns true if field default_name_type is set (has been assigned a value) and false otherwise */ + public boolean isSetDefault_name_type() { + return this.default_name_type != null; + } + + public void setDefault_name_typeIsSet(boolean value) { + if (!value) { + this.default_name_type = null; + } + } + + public String getDefault_value_type() { + return this.default_value_type; + } + + public CqlMetadata setDefault_value_type(String default_value_type) { + this.default_value_type = default_value_type; + return this; + } + + public void unsetDefault_value_type() { + this.default_value_type = null; + } + + /** Returns true if field default_value_type is set (has been assigned a value) and false otherwise */ + public boolean isSetDefault_value_type() { + return this.default_value_type != null; + } + + public void setDefault_value_typeIsSet(boolean value) { + if (!value) { + this.default_value_type = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case NAME_TYPES: + if (value == null) { + unsetName_types(); + } else { + setName_types((Map)value); + } + break; + + case VALUE_TYPES: + if (value == null) { + unsetValue_types(); + } else { + setValue_types((Map)value); + } + break; + + case DEFAULT_NAME_TYPE: + if (value == null) { + unsetDefault_name_type(); + } else { + setDefault_name_type((String)value); + } + break; + + case DEFAULT_VALUE_TYPE: + if (value == null) { + unsetDefault_value_type(); + } else { + setDefault_value_type((String)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case NAME_TYPES: + return getName_types(); + + case VALUE_TYPES: + return getValue_types(); + + case DEFAULT_NAME_TYPE: + return getDefault_name_type(); + + case DEFAULT_VALUE_TYPE: + return getDefault_value_type(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case NAME_TYPES: + return isSetName_types(); + case VALUE_TYPES: + return isSetValue_types(); + case DEFAULT_NAME_TYPE: + return isSetDefault_name_type(); + case DEFAULT_VALUE_TYPE: + return isSetDefault_value_type(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof CqlMetadata) + return this.equals((CqlMetadata)that); + return false; + } + + public boolean equals(CqlMetadata that) { + if (that == null) + return false; + + boolean this_present_name_types = true && this.isSetName_types(); + boolean that_present_name_types = true && that.isSetName_types(); + if (this_present_name_types || that_present_name_types) { + if (!(this_present_name_types && that_present_name_types)) + return false; + if (!this.name_types.equals(that.name_types)) + return false; + } + + boolean this_present_value_types = true && this.isSetValue_types(); + boolean that_present_value_types = true && that.isSetValue_types(); + if (this_present_value_types || that_present_value_types) { + if (!(this_present_value_types && that_present_value_types)) + return false; + if (!this.value_types.equals(that.value_types)) + return false; + } + + boolean this_present_default_name_type = true && this.isSetDefault_name_type(); + boolean that_present_default_name_type = true && that.isSetDefault_name_type(); + if (this_present_default_name_type || that_present_default_name_type) { + if (!(this_present_default_name_type && that_present_default_name_type)) + return false; + if (!this.default_name_type.equals(that.default_name_type)) + return false; + } + + boolean this_present_default_value_type = true && this.isSetDefault_value_type(); + boolean that_present_default_value_type = true && that.isSetDefault_value_type(); + if (this_present_default_value_type || that_present_default_value_type) { + if (!(this_present_default_value_type && that_present_default_value_type)) + return false; + if (!this.default_value_type.equals(that.default_value_type)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + HashCodeBuilder builder = new HashCodeBuilder(); + + boolean present_name_types = true && (isSetName_types()); + builder.append(present_name_types); + if (present_name_types) + builder.append(name_types); + + boolean present_value_types = true && (isSetValue_types()); + builder.append(present_value_types); + if (present_value_types) + builder.append(value_types); + + boolean present_default_name_type = true && (isSetDefault_name_type()); + builder.append(present_default_name_type); + if (present_default_name_type) + builder.append(default_name_type); + + boolean present_default_value_type = true && (isSetDefault_value_type()); + builder.append(present_default_value_type); + if (present_default_value_type) + builder.append(default_value_type); + + return builder.toHashCode(); + } + + public int compareTo(CqlMetadata other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + CqlMetadata typedOther = (CqlMetadata)other; + + lastComparison = Boolean.valueOf(isSetName_types()).compareTo(typedOther.isSetName_types()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetName_types()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.name_types, typedOther.name_types); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetValue_types()).compareTo(typedOther.isSetValue_types()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetValue_types()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.value_types, typedOther.value_types); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetDefault_name_type()).compareTo(typedOther.isSetDefault_name_type()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetDefault_name_type()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.default_name_type, typedOther.default_name_type); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetDefault_value_type()).compareTo(typedOther.isSetDefault_value_type()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetDefault_value_type()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.default_value_type, typedOther.default_value_type); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField field; + iprot.readStructBegin(); + while (true) + { + field = iprot.readFieldBegin(); + if (field.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (field.id) { + case 1: // NAME_TYPES + if (field.type == org.apache.thrift.protocol.TType.MAP) { + { + org.apache.thrift.protocol.TMap _map61 = iprot.readMapBegin(); + this.name_types = new HashMap(2*_map61.size); + for (int _i62 = 0; _i62 < _map61.size; ++_i62) + { + ByteBuffer _key63; + String _val64; + _key63 = iprot.readBinary(); + _val64 = iprot.readString(); + this.name_types.put(_key63, _val64); + } + iprot.readMapEnd(); + } + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + } + break; + case 2: // VALUE_TYPES + if (field.type == org.apache.thrift.protocol.TType.MAP) { + { + org.apache.thrift.protocol.TMap _map65 = iprot.readMapBegin(); + this.value_types = new HashMap(2*_map65.size); + for (int _i66 = 0; _i66 < _map65.size; ++_i66) + { + ByteBuffer _key67; + String _val68; + _key67 = iprot.readBinary(); + _val68 = iprot.readString(); + this.value_types.put(_key67, _val68); + } + iprot.readMapEnd(); + } + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + } + break; + case 3: // DEFAULT_NAME_TYPE + if (field.type == org.apache.thrift.protocol.TType.STRING) { + this.default_name_type = iprot.readString(); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + } + break; + case 4: // DEFAULT_VALUE_TYPE + if (field.type == org.apache.thrift.protocol.TType.STRING) { + this.default_value_type = iprot.readString(); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + } + break; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + + // check for required fields of primitive type, which can't be checked in the validate method + validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (this.name_types != null) { + oprot.writeFieldBegin(NAME_TYPES_FIELD_DESC); + { + oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, this.name_types.size())); + for (Map.Entry _iter69 : this.name_types.entrySet()) + { + oprot.writeBinary(_iter69.getKey()); + oprot.writeString(_iter69.getValue()); + } + oprot.writeMapEnd(); + } + oprot.writeFieldEnd(); + } + if (this.value_types != null) { + oprot.writeFieldBegin(VALUE_TYPES_FIELD_DESC); + { + oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, this.value_types.size())); + for (Map.Entry _iter70 : this.value_types.entrySet()) + { + oprot.writeBinary(_iter70.getKey()); + oprot.writeString(_iter70.getValue()); + } + oprot.writeMapEnd(); + } + oprot.writeFieldEnd(); + } + if (this.default_name_type != null) { + oprot.writeFieldBegin(DEFAULT_NAME_TYPE_FIELD_DESC); + oprot.writeString(this.default_name_type); + oprot.writeFieldEnd(); + } + if (this.default_value_type != null) { + oprot.writeFieldBegin(DEFAULT_VALUE_TYPE_FIELD_DESC); + oprot.writeString(this.default_value_type); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("CqlMetadata("); + boolean first = true; + + sb.append("name_types:"); + if (this.name_types == null) { + sb.append("null"); + } else { + sb.append(this.name_types); + } + first = false; + if (!first) sb.append(", "); + sb.append("value_types:"); + if (this.value_types == null) { + sb.append("null"); + } else { + sb.append(this.value_types); + } + first = false; + if (!first) sb.append(", "); + sb.append("default_name_type:"); + if (this.default_name_type == null) { + sb.append("null"); + } else { + sb.append(this.default_name_type); + } + first = false; + if (!first) sb.append(", "); + sb.append("default_value_type:"); + if (this.default_value_type == null) { + sb.append("null"); + } else { + sb.append(this.default_value_type); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + if (name_types == null) { + throw new org.apache.thrift.protocol.TProtocolException("Required field 'name_types' was not present! Struct: " + toString()); + } + if (value_types == null) { + throw new org.apache.thrift.protocol.TProtocolException("Required field 'value_types' was not present! Struct: " + toString()); + } + if (default_name_type == null) { + throw new org.apache.thrift.protocol.TProtocolException("Required field 'default_name_type' was not present! Struct: " + toString()); + } + if (default_value_type == null) { + throw new org.apache.thrift.protocol.TProtocolException("Required field 'default_value_type' was not present! Struct: " + toString()); + } + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + +} + Modified: cassandra/trunk/interface/thrift/gen-java/org/apache/cassandra/thrift/CqlResult.java URL: http://svn.apache.org/viewvc/cassandra/trunk/interface/thrift/gen-java/org/apache/cassandra/thrift/CqlResult.java?rev=1165750&r1=1165749&r2=1165750&view=diff ============================================================================== --- cassandra/trunk/interface/thrift/gen-java/org/apache/cassandra/thrift/CqlResult.java (original) +++ cassandra/trunk/interface/thrift/gen-java/org/apache/cassandra/thrift/CqlResult.java Tue Sep 6 16:21:29 2011 @@ -48,6 +48,7 @@ public class CqlResult implements org.ap private static final org.apache.thrift.protocol.TField TYPE_FIELD_DESC = new org.apache.thrift.protocol.TField("type", org.apache.thrift.protocol.TType.I32, (short)1); private static final org.apache.thrift.protocol.TField ROWS_FIELD_DESC = new org.apache.thrift.protocol.TField("rows", org.apache.thrift.protocol.TType.LIST, (short)2); private static final org.apache.thrift.protocol.TField NUM_FIELD_DESC = new org.apache.thrift.protocol.TField("num", org.apache.thrift.protocol.TType.I32, (short)3); + private static final org.apache.thrift.protocol.TField SCHEMA_FIELD_DESC = new org.apache.thrift.protocol.TField("schema", org.apache.thrift.protocol.TType.STRUCT, (short)4); /** * @@ -56,6 +57,7 @@ public class CqlResult implements org.ap public CqlResultType type; public List rows; public int num; + public CqlMetadata schema; /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ public enum _Fields implements org.apache.thrift.TFieldIdEnum { @@ -65,7 +67,8 @@ public class CqlResult implements org.ap */ TYPE((short)1, "type"), ROWS((short)2, "rows"), - NUM((short)3, "num"); + NUM((short)3, "num"), + SCHEMA((short)4, "schema"); private static final Map byName = new HashMap(); @@ -86,6 +89,8 @@ public class CqlResult implements org.ap return ROWS; case 3: // NUM return NUM; + case 4: // SCHEMA + return SCHEMA; default: return null; } @@ -139,6 +144,8 @@ public class CqlResult implements org.ap new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, CqlRow.class)))); tmpMap.put(_Fields.NUM, new org.apache.thrift.meta_data.FieldMetaData("num", org.apache.thrift.TFieldRequirementType.OPTIONAL, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))); + tmpMap.put(_Fields.SCHEMA, new org.apache.thrift.meta_data.FieldMetaData("schema", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, CqlMetadata.class))); metaDataMap = Collections.unmodifiableMap(tmpMap); org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(CqlResult.class, metaDataMap); } @@ -170,6 +177,9 @@ public class CqlResult implements org.ap this.rows = __this__rows; } this.num = other.num; + if (other.isSetSchema()) { + this.schema = new CqlMetadata(other.schema); + } } public CqlResult deepCopy() { @@ -182,6 +192,7 @@ public class CqlResult implements org.ap this.rows = null; setNumIsSet(false); this.num = 0; + this.schema = null; } /** @@ -278,6 +289,30 @@ public class CqlResult implements org.ap __isset_bit_vector.set(__NUM_ISSET_ID, value); } + public CqlMetadata getSchema() { + return this.schema; + } + + public CqlResult setSchema(CqlMetadata schema) { + this.schema = schema; + return this; + } + + public void unsetSchema() { + this.schema = null; + } + + /** Returns true if field schema is set (has been assigned a value) and false otherwise */ + public boolean isSetSchema() { + return this.schema != null; + } + + public void setSchemaIsSet(boolean value) { + if (!value) { + this.schema = null; + } + } + public void setFieldValue(_Fields field, Object value) { switch (field) { case TYPE: @@ -304,6 +339,14 @@ public class CqlResult implements org.ap } break; + case SCHEMA: + if (value == null) { + unsetSchema(); + } else { + setSchema((CqlMetadata)value); + } + break; + } } @@ -318,6 +361,9 @@ public class CqlResult implements org.ap case NUM: return new Integer(getNum()); + case SCHEMA: + return getSchema(); + } throw new IllegalStateException(); } @@ -335,6 +381,8 @@ public class CqlResult implements org.ap return isSetRows(); case NUM: return isSetNum(); + case SCHEMA: + return isSetSchema(); } throw new IllegalStateException(); } @@ -379,6 +427,15 @@ public class CqlResult implements org.ap return false; } + boolean this_present_schema = true && this.isSetSchema(); + boolean that_present_schema = true && that.isSetSchema(); + if (this_present_schema || that_present_schema) { + if (!(this_present_schema && that_present_schema)) + return false; + if (!this.schema.equals(that.schema)) + return false; + } + return true; } @@ -401,6 +458,11 @@ public class CqlResult implements org.ap if (present_num) builder.append(num); + boolean present_schema = true && (isSetSchema()); + builder.append(present_schema); + if (present_schema) + builder.append(schema); + return builder.toHashCode(); } @@ -442,6 +504,16 @@ public class CqlResult implements org.ap return lastComparison; } } + lastComparison = Boolean.valueOf(isSetSchema()).compareTo(typedOther.isSetSchema()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetSchema()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.schema, typedOther.schema); + if (lastComparison != 0) { + return lastComparison; + } + } return 0; } @@ -469,14 +541,14 @@ public class CqlResult implements org.ap case 2: // ROWS if (field.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list61 = iprot.readListBegin(); - this.rows = new ArrayList(_list61.size); - for (int _i62 = 0; _i62 < _list61.size; ++_i62) + org.apache.thrift.protocol.TList _list71 = iprot.readListBegin(); + this.rows = new ArrayList(_list71.size); + for (int _i72 = 0; _i72 < _list71.size; ++_i72) { - CqlRow _elem63; - _elem63 = new CqlRow(); - _elem63.read(iprot); - this.rows.add(_elem63); + CqlRow _elem73; + _elem73 = new CqlRow(); + _elem73.read(iprot); + this.rows.add(_elem73); } iprot.readListEnd(); } @@ -492,6 +564,14 @@ public class CqlResult implements org.ap org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); } break; + case 4: // SCHEMA + if (field.type == org.apache.thrift.protocol.TType.STRUCT) { + this.schema = new CqlMetadata(); + this.schema.read(iprot); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); + } + break; default: org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type); } @@ -517,9 +597,9 @@ public class CqlResult implements org.ap oprot.writeFieldBegin(ROWS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.rows.size())); - for (CqlRow _iter64 : this.rows) + for (CqlRow _iter74 : this.rows) { - _iter64.write(oprot); + _iter74.write(oprot); } oprot.writeListEnd(); } @@ -531,6 +611,13 @@ public class CqlResult implements org.ap oprot.writeI32(this.num); oprot.writeFieldEnd(); } + if (this.schema != null) { + if (isSetSchema()) { + oprot.writeFieldBegin(SCHEMA_FIELD_DESC); + this.schema.write(oprot); + oprot.writeFieldEnd(); + } + } oprot.writeFieldStop(); oprot.writeStructEnd(); } @@ -563,6 +650,16 @@ public class CqlResult implements org.ap sb.append(this.num); first = false; } + if (isSetSchema()) { + if (!first) sb.append(", "); + sb.append("schema:"); + if (this.schema == null) { + sb.append("null"); + } else { + sb.append(this.schema); + } + first = false; + } sb.append(")"); return sb.toString(); } Modified: cassandra/trunk/src/java/org/apache/cassandra/cli/CliClient.java URL: http://svn.apache.org/viewvc/cassandra/trunk/src/java/org/apache/cassandra/cli/CliClient.java?rev=1165750&r1=1165749&r2=1165750&view=diff ============================================================================== --- cassandra/trunk/src/java/org/apache/cassandra/cli/CliClient.java (original) +++ cassandra/trunk/src/java/org/apache/cassandra/cli/CliClient.java Tue Sep 6 16:21:29 2011 @@ -76,7 +76,7 @@ public class CliClient Function(AbstractType validator) { - this.validator = validator; + this.validator = validator; } public AbstractType getValidator() @@ -98,7 +98,7 @@ public class CliClient return functionNames.toString(); } } - + /* * the add keyspace command requires a list of arguments, * this enum defines which arguments are valid @@ -526,7 +526,7 @@ public class CliClient private AbstractType getFormatType(String compareWith) { Function function; - + try { function = Function.valueOf(compareWith.toUpperCase()); Modified: cassandra/trunk/src/java/org/apache/cassandra/config/Schema.java URL: http://svn.apache.org/viewvc/cassandra/trunk/src/java/org/apache/cassandra/config/Schema.java?rev=1165750&r1=1165749&r2=1165750&view=diff ============================================================================== --- cassandra/trunk/src/java/org/apache/cassandra/config/Schema.java (original) +++ cassandra/trunk/src/java/org/apache/cassandra/config/Schema.java Tue Sep 6 16:21:29 2011 @@ -32,10 +32,15 @@ import org.apache.cassandra.utils.Pair; import com.google.common.collect.BiMap; import com.google.common.collect.HashBiMap; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + import org.cliffc.high_scale_lib.NonBlockingHashMap; public class Schema { + private static final Logger logger = LoggerFactory.getLogger(Schema.class); + public static final UUID INITIAL_VERSION = new UUID(4096, 0); // has type nibble set to 1, everything else to zero. public static final Schema instance = new Schema(INITIAL_VERSION); @@ -377,6 +382,7 @@ public class Schema if (cfIdMap.containsKey(key)) throw new ConfigurationException("Attempt to assign id to existing column family."); + logger.debug("Adding {} to cfIdMap", cfm); cfIdMap.put(key, cfm.cfId); } Modified: cassandra/trunk/src/java/org/apache/cassandra/cql/QueryProcessor.java URL: http://svn.apache.org/viewvc/cassandra/trunk/src/java/org/apache/cassandra/cql/QueryProcessor.java?rev=1165750&r1=1165749&r2=1165750&view=diff ============================================================================== --- cassandra/trunk/src/java/org/apache/cassandra/cql/QueryProcessor.java (original) +++ cassandra/trunk/src/java/org/apache/cassandra/cql/QueryProcessor.java Tue Sep 6 16:21:29 2011 @@ -33,16 +33,15 @@ import java.util.concurrent.TimeoutExcep import org.apache.cassandra.auth.Permission; import org.apache.cassandra.concurrent.Stage; import org.apache.cassandra.concurrent.StageManager; -import org.apache.cassandra.config.CFMetaData; -import org.apache.cassandra.config.ConfigurationException; -import org.apache.cassandra.config.KSMetaData; -import org.apache.cassandra.config.Schema; +import org.apache.cassandra.config.*; import org.apache.cassandra.db.CounterColumn; import org.apache.cassandra.db.*; import org.apache.cassandra.db.context.CounterContext; import org.apache.cassandra.db.filter.QueryPath; import org.apache.cassandra.db.marshal.AbstractType; +import org.apache.cassandra.db.marshal.AsciiType; import org.apache.cassandra.db.marshal.MarshalException; +import org.apache.cassandra.db.marshal.TypeParser; import org.apache.cassandra.db.migration.*; import org.apache.cassandra.dht.*; import org.apache.cassandra.dht.Token; @@ -559,6 +558,10 @@ public class QueryProcessor List cqlRows = new ArrayList(); result.type = CqlResultType.ROWS; + result.schema = new CqlMetadata(new HashMap(), + new HashMap(), + metadata.comparator.toString(), + TypeParser.getShortName(metadata.getDefaultValidator())); // Create the result set for (org.apache.cassandra.db.Row row : rows) @@ -567,7 +570,63 @@ public class QueryProcessor if (row.cf == null) continue; - List thriftColumns = extractThriftColumns(select, metadata, row); + List thriftColumns = new ArrayList(); + if (select.isColumnRange()) + { + if (select.isWildcard()) + { + // prepend key + thriftColumns.add(new Column(metadata.getKeyName()).setValue(row.key.key).setTimestamp(-1)); + result.schema.name_types.put(metadata.getKeyName(), TypeParser.getShortName(AsciiType.instance)); + result.schema.value_types.put(metadata.getKeyName(), TypeParser.getShortName(metadata.getKeyValidator())); + } + + // preserve comparator order + for (IColumn c : row.cf.getSortedColumns()) + { + if (c.isMarkedForDelete()) + continue; + thriftColumns.add(thriftify(c)); + } + } + else + { + String keyString = getKeyString(metadata); + + // order columns in the order they were asked for + for (Term term : select.getColumnNames()) + { + if (term.getText().equalsIgnoreCase(keyString)) + { + // preserve case of key as it was requested + ByteBuffer requestedKey = ByteBufferUtil.bytes(term.getText()); + thriftColumns.add(new Column(requestedKey).setValue(row.key.key).setTimestamp(-1)); + result.schema.name_types.put(requestedKey, TypeParser.getShortName(AsciiType.instance)); + result.schema.value_types.put(requestedKey, TypeParser.getShortName(metadata.getKeyValidator())); + continue; + } + + ByteBuffer name; + try + { + name = term.getByteBuffer(metadata.comparator); + } + catch (InvalidRequestException e) + { + throw new AssertionError(e); + } + + ColumnDefinition cd = metadata.getColumnDefinition(name); + if (cd != null) + result.schema.value_types.put(name, TypeParser.getShortName(cd.getValidator())); + IColumn c = row.cf.getColumn(name); + if (c == null || c.isMarkedForDelete()) + thriftColumns.add(new Column().setName(name)); + else + thriftColumns.add(thriftify(c)); + } + } + // Create a new row, add the columns to it, and then add it to the list of rows CqlRow cqlRow = new CqlRow(); cqlRow.key = row.key.key; @@ -884,60 +943,6 @@ public class QueryProcessor return null; // We should never get here. } - private static List extractThriftColumns(SelectStatement select, CFMetaData metadata, Row row) - { - List thriftColumns = new ArrayList(); - if (select.isColumnRange()) - { - if (select.isWildcard()) - { - // prepend key - thriftColumns.add(new Column(metadata.getKeyName()).setValue(row.key.key).setTimestamp(-1)); - } - - // preserve comparator order - for (IColumn c : row.cf.getSortedColumns()) - { - if (c.isMarkedForDelete()) - continue; - thriftColumns.add(thriftify(c)); - } - } - else - { - String keyString = getKeyString(metadata); - - // order columns in the order they were asked for - for (Term term : select.getColumnNames()) - { - if (term.getText().equalsIgnoreCase(keyString)) - { - // preserve case of key as it was requested - ByteBuffer requestedKey = ByteBufferUtil.bytes(term.getText()); - thriftColumns.add(new Column(requestedKey).setValue(row.key.key).setTimestamp(-1)); - continue; - } - - ByteBuffer name; - try - { - name = term.getByteBuffer(metadata.comparator); - } - catch (InvalidRequestException e) - { - throw new AssertionError(e); - } - - IColumn c = row.cf.getColumn(name); - if (c == null || c.isMarkedForDelete()) - thriftColumns.add(new Column().setName(name)); - else - thriftColumns.add(thriftify(c)); - } - } - return thriftColumns; - } - private static Column thriftify(IColumn c) { ByteBuffer value = (c instanceof CounterColumn) Modified: cassandra/trunk/src/java/org/apache/cassandra/cql/jdbc/TypesMap.java URL: http://svn.apache.org/viewvc/cassandra/trunk/src/java/org/apache/cassandra/cql/jdbc/TypesMap.java?rev=1165750&r1=1165749&r2=1165750&view=diff ============================================================================== --- cassandra/trunk/src/java/org/apache/cassandra/cql/jdbc/TypesMap.java (original) +++ cassandra/trunk/src/java/org/apache/cassandra/cql/jdbc/TypesMap.java Tue Sep 6 16:21:29 2011 @@ -24,7 +24,7 @@ public class TypesMap map.put("org.apache.cassandra.db.marshal.UUIDType", JdbcUUID.instance); } - public static AbstractJdbcType getTermForComparator(String comparator) + public static AbstractJdbcType getTypeForComparator(String comparator) { // If not fully qualified, assume it's the short name for a built-in. if ((comparator != null) && (!comparator.contains("."))) Modified: cassandra/trunk/src/java/org/apache/cassandra/db/marshal/AbstractType.java URL: http://svn.apache.org/viewvc/cassandra/trunk/src/java/org/apache/cassandra/db/marshal/AbstractType.java?rev=1165750&r1=1165749&r2=1165750&view=diff ============================================================================== --- cassandra/trunk/src/java/org/apache/cassandra/db/marshal/AbstractType.java (original) +++ cassandra/trunk/src/java/org/apache/cassandra/db/marshal/AbstractType.java Tue Sep 6 16:21:29 2011 @@ -161,6 +161,9 @@ public abstract class AbstractType im /** * This must be overriden by subclasses if necessary so that for any * AbstractType, this == TypeParser.parse(toString()). + * + * Note that for backwards compatibility this includes the full classname. + * For CQL purposes the short name is fine. */ @Override public String toString() Modified: cassandra/trunk/src/java/org/apache/cassandra/db/marshal/TypeParser.java URL: http://svn.apache.org/viewvc/cassandra/trunk/src/java/org/apache/cassandra/db/marshal/TypeParser.java?rev=1165750&r1=1165749&r2=1165750&view=diff ============================================================================== --- cassandra/trunk/src/java/org/apache/cassandra/db/marshal/TypeParser.java (original) +++ cassandra/trunk/src/java/org/apache/cassandra/db/marshal/TypeParser.java Tue Sep 6 16:21:29 2011 @@ -92,6 +92,11 @@ public class TypeParser return parse(compareWith == null ? null : compareWith.toString()); } + public static String getShortName(AbstractType type) + { + return type.getClass().getSimpleName(); + } + /** * Parse an AbstractType from current position of this parser. */