Add intended Array.java file that accidentally was patched into the

wrong directory.

diff --git a/src/backend/libpq/md5.c b/src/backend/libpq/md5.c
index 76d54d50b0d799e24aa60ae8c039e8e38590b7c4..16a0ed5817c72fcb8c9cdd0caad3a69a8ac51411 100644 (file)
--- a/src/backend/libpq/md5.c
+++ b/src/backend/libpq/md5.c
@@ -24,10 +24,6 @@
  *     PRIVATE FUNCTIONS
  */
 
-typedef unsigned char unsigned8;
-typedef unsigned int  unsigned32;
-typedef unsigned long unsigned64;
-
 #ifdef FRONTEND
 #undef palloc
 #define palloc malloc
@@ -39,13 +35,13 @@ typedef unsigned long unsigned64;
  *     The returned array is allocated using malloc.  the caller should free it
  *     when it is no longer needed.
  */
-static unsigned8 *
-createPaddedCopyWithLength(unsigned8 *b, unsigned32 *l)
+static uint8 *
+createPaddedCopyWithLength(uint8 *b, uint32 *l)
 {
-       unsigned8  *ret;
-       unsigned32 q;
-       unsigned32 len, newLen448;
-       unsigned64 len64;
+       uint8  *ret;
+       uint32 q;
+       uint32 len, newLen448;
+       uint32 len_high, len_low;       /* 64-bit value split into 32-bit sections */
 
        len = ((b == NULL) ? 0 : *l);
        newLen448 = len + 64 - (len % 64) - 8;
@@ -53,11 +49,11 @@ createPaddedCopyWithLength(unsigned8 *b, unsigned32 *l)
                newLen448 += 64;
 
        *l = newLen448 + 8;
-       if ((ret = (unsigned8 *) malloc(sizeof(unsigned8) * *l)) == NULL)
+       if ((ret = (uint8 *) malloc(sizeof(uint8) * *l)) == NULL)
                return NULL;
 
        if (b != NULL)
-               memcpy(ret, b, sizeof(unsigned8) * len);
+               memcpy(ret, b, sizeof(uint8) * len);
 
        /* pad */
        ret[len] = 0x80;
@@ -65,24 +61,26 @@ createPaddedCopyWithLength(unsigned8 *b, unsigned32 *l)
                ret[q] = 0x00;
 
        /* append length as a 64 bit bitcount */
-       len64 = len;
-       len64 <<= 3;
+       len_low = len;
+       /* split into two 32-bit values */
+       /* we only look at the bottom 32-bits */
+       len_high = len >> 29;
+       len_low <<= 3;
        q = newLen448;
-       ret[q++] = (len64 & 0xFF);
-       len64 >>= 8;
-       ret[q++] = (len64 & 0xFF);
-       len64 >>= 8;
-       ret[q++] = (len64 & 0xFF);
-       len64 >>= 8;
-       ret[q++] = (len64 & 0xFF);
-       len64 >>= 8;
-       ret[q++] = (len64 & 0xFF);
-       len64 >>= 8;
-       ret[q++] = (len64 & 0xFF);
-       len64 >>= 8;
-       ret[q++] = (len64 & 0xFF);
-       len64 >>= 8;
-       ret[q] = (len64 & 0xFF);
+       ret[q++] = (len_low & 0xff);
+       len_low >>= 8;
+       ret[q++] = (len_low & 0xff);
+       len_low >>= 8;
+       ret[q++] = (len_low & 0xff);
+       len_low >>= 8;
+       ret[q++] = (len_low & 0xff);
+       ret[q++] = (len_high & 0xff);
+       len_high >>= 8;
+       ret[q++] = (len_high & 0xff);
+       len_high >>= 8;
+       ret[q++] = (len_high & 0xff);
+       len_high >>= 8;
+       ret[q] = (len_high & 0xff);
 
        return ret;
 }
@@ -94,9 +92,9 @@ createPaddedCopyWithLength(unsigned8 *b, unsigned32 *l)
 #define ROT_LEFT(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
 
 static void
-doTheRounds(unsigned32 X[16], unsigned32 state[4])
+doTheRounds(uint32 X[16], uint32 state[4])
 {
-       unsigned32 a, b, c, d;
+       uint32 a, b, c, d;
 
        a = state[0];
        b = state[1];
@@ -182,13 +180,13 @@ doTheRounds(unsigned32 X[16], unsigned32 state[4])
 }
 
 static int
-calculateDigestFromBuffer(unsigned8 *b, unsigned32 len, unsigned8 sum[16])
+calculateDigestFromBuffer(uint8 *b, uint32 len, uint8 sum[16])
 {
-       register unsigned32 i, j, k, newI;
-       unsigned32 l;
-       unsigned8 *input;
-       register unsigned32 *wbp;
-       unsigned32 workBuff[16], state[4];
+       register uint32 i, j, k, newI;
+       uint32 l;
+       uint8 *input;
+       register uint32 *wbp;
+       uint32 workBuff[16], state[4];
 
        l = len;
 
@@ -223,19 +221,19 @@ calculateDigestFromBuffer(unsigned8 *b, unsigned32 len, unsigned8 sum[16])
        j = 0;
        for (i = 0; i < 4; i++) {
                k = state[i];
-               sum[j++] = (k & 0xFF);
+               sum[j++] = (k & 0xff);
                k >>= 8;
-               sum[j++] = (k & 0xFF);
+               sum[j++] = (k & 0xff);
                k >>= 8;
-               sum[j++] = (k & 0xFF);
+               sum[j++] = (k & 0xff);
                k >>= 8;
-               sum[j++] = (k & 0xFF);
+               sum[j++] = (k & 0xff);
        }
        return 1;
 }
 
 static void
-bytesToHex(unsigned8 b[16], char *s)
+bytesToHex(uint8 b[16], char *s)
 {
        static char *hex = "0123456789abcdef";
        int         q, w;
@@ -280,9 +278,9 @@ bytesToHex(unsigned8 b[16], char *s)
 bool
 md5_hash(const void *buff, size_t len, char *hexsum)
 {
-       unsigned8 sum[16];
+       uint8 sum[16];
 
-       if (!calculateDigestFromBuffer((unsigned8 *) buff, len, sum))
+       if (!calculateDigestFromBuffer((uint8 *) buff, len, sum))
                return false;
 
        bytesToHex(sum, hexsum);

diff --git a/src/interfaces/jdbc/org/postgresql/jdbc2/Array.java b/src/interfaces/jdbc/org/postgresql/jdbc2/Array.java
index 16015b881bd8ee6f2f4852bd1abe117f69b5dc94..5e0f86ea35e5cb3f7658c970fc7c61a4e4ac91f1 100644 (file)
--- a/src/interfaces/jdbc/org/postgresql/jdbc2/Array.java
+++ b/src/interfaces/jdbc/org/postgresql/jdbc2/Array.java
@@ -169,11 +169,11 @@ public class Array implements java.sql.Array
        }
 
        public int getBaseType() throws SQLException {
-                return conn.getSQLType(getBaseTypeName());
+               return Field.getSQLType( getBaseTypeName() );
        }
 
        public String getBaseTypeName() throws SQLException {
-                String fType = field.getPGType();
+               String fType = field.getTypeName();
                if( fType.charAt(0) == '_' )
                        fType = fType.substring(1);
                return fType;
@@ -195,12 +195,12 @@ public class Array implements java.sql.Array
                Object array = getArray( index, count, map );
                Vector rows = new Vector();
                Field[] fields = new Field[2];
-                fields[0] = new Field(conn, "INDEX", conn.getOID("int2"), 2);
+               fields[0] = new Field(conn, "INDEX", field.getOID("int2"), 2);
                switch ( getBaseType() )
                {
                        case Types.BIT:
                                boolean[] booleanArray = (boolean[]) array;
-                                fields[1] = new Field(conn, "VALUE", conn.getOID("bool"), 1);
+                               fields[1] = new Field(conn, "VALUE", field.getOID("bool"), 1);
                                for( int i=0; i<booleanArray.length; i++ ) {
                                        byte[][] tuple = new byte[2][0];
                                        tuple[0] = conn.getEncoding().encode( Integer.toString((int)index+i) ); // Index 
@@ -208,11 +208,11 @@ public class Array implements java.sql.Array
                                        rows.addElement(tuple);
                                }
                        case Types.SMALLINT:
-                                fields[1] = new Field(conn, "VALUE", conn.getOID("int2"), 2);
+                               fields[1] = new Field(conn, "VALUE", field.getOID("int2"), 2);
                        case Types.INTEGER:
                                int[] intArray = (int[]) array;
                                if( fields[1] == null )
-                                        fields[1] = new Field(conn, "VALUE", conn.getOID("int4"), 4);
+                                       fields[1] = new Field(conn, "VALUE", field.getOID("int4"), 4);
                                for( int i=0; i<intArray.length; i++ ) {
                                        byte[][] tuple = new byte[2][0];
                                        tuple[0] = conn.getEncoding().encode( Integer.toString((int)index+i) ); // Index 
@@ -222,7 +222,7 @@ public class Array implements java.sql.Array
                                break;
                        case Types.BIGINT:
                                long[] longArray = (long[]) array;
-                                fields[1] = new Field(conn, "VALUE", conn.getOID("int8"), 8);
+                               fields[1] = new Field(conn, "VALUE", field.getOID("int8"), 8);
                                for( int i=0; i<longArray.length; i++ ) {
                                        byte[][] tuple = new byte[2][0];
                                        tuple[0] = conn.getEncoding().encode( Integer.toString((int)index+i) ); // Index 
@@ -232,7 +232,7 @@ public class Array implements java.sql.Array
                                break;
                        case Types.NUMERIC:
                                BigDecimal[] bdArray = (BigDecimal[]) array;
-                                fields[1] = new Field(conn, "VALUE", conn.getOID("numeric"), -1);
+                               fields[1] = new Field(conn, "VALUE", field.getOID("numeric"), -1);
                                for( int i=0; i<bdArray.length; i++ ) {
                                        byte[][] tuple = new byte[2][0];
                                        tuple[0] = conn.getEncoding().encode( Integer.toString((int)index+i) ); // Index 
@@ -242,7 +242,7 @@ public class Array implements java.sql.Array
                                break;
                        case Types.REAL:
                                float[] floatArray = (float[]) array;
-                                fields[1] = new Field(conn, "VALUE", conn.getOID("float4"), 4);
+                               fields[1] = new Field(conn, "VALUE", field.getOID("float4"), 4);
                                for( int i=0; i<floatArray.length; i++ ) {
                                        byte[][] tuple = new byte[2][0];
                                        tuple[0] = conn.getEncoding().encode( Integer.toString((int)index+i) ); // Index 
@@ -252,7 +252,7 @@ public class Array implements java.sql.Array
                                break;
                        case Types.DOUBLE:
                                double[] doubleArray = (double[]) array;
-                                fields[1] = new Field(conn, "VALUE", conn.getOID("float8"), 8);
+                               fields[1] = new Field(conn, "VALUE", field.getOID("float8"), 8);
                                for( int i=0; i<doubleArray.length; i++ ) {
                                        byte[][] tuple = new byte[2][0];
                                        tuple[0] = conn.getEncoding().encode( Integer.toString((int)index+i) ); // Index 
@@ -261,11 +261,11 @@ public class Array implements java.sql.Array
                                }
                                break;
                        case Types.CHAR:
-                                fields[1] = new Field(conn, "VALUE", conn.getOID("char"), 1);
+                               fields[1] = new Field(conn, "VALUE", field.getOID("char"), 1);
                        case Types.VARCHAR:
                                String[] strArray = (String[]) array;
                                if( fields[1] == null )
-                                        fields[1] = new Field(conn, "VALUE", conn.getOID("varchar"), -1);
+                                       fields[1] = new Field(conn, "VALUE", field.getOID("varchar"), -1);
                                for( int i=0; i<strArray.length; i++ ) {
                                        byte[][] tuple = new byte[2][0];
                                        tuple[0] = conn.getEncoding().encode( Integer.toString((int)index+i) ); // Index 
@@ -275,7 +275,7 @@ public class Array implements java.sql.Array
                                break;
                        case Types.DATE:
                                java.sql.Date[] dateArray = (java.sql.Date[]) array;
-                                fields[1] = new Field(conn, "VALUE", conn.getOID("date"), 4);
+                               fields[1] = new Field(conn, "VALUE", field.getOID("date"), 4);
                                for( int i=0; i<dateArray.length; i++ ) {
                                        byte[][] tuple = new byte[2][0];
                                        tuple[0] = conn.getEncoding().encode( Integer.toString((int)index+i) ); // Index 
@@ -285,7 +285,7 @@ public class Array implements java.sql.Array
                                break;
                        case Types.TIME:
                                java.sql.Time[] timeArray = (java.sql.Time[]) array;
-                                fields[1] = new Field(conn, "VALUE", conn.getOID("time"), 8);
+                               fields[1] = new Field(conn, "VALUE", field.getOID("time"), 8);
                                for( int i=0; i<timeArray.length; i++ ) {
                                        byte[][] tuple = new byte[2][0];
                                        tuple[0] = conn.getEncoding().encode( Integer.toString((int)index+i) ); // Index 
@@ -295,7 +295,7 @@ public class Array implements java.sql.Array
                                break;
                        case Types.TIMESTAMP:
                                java.sql.Timestamp[] timestampArray = (java.sql.Timestamp[]) array;
-                                fields[1] = new Field(conn, "VALUE", conn.getOID("timestamp"), 8);
+                               fields[1] = new Field(conn, "VALUE", field.getOID("timestamp"), 8);
                                for( int i=0; i<timestampArray.length; i++ ) {
                                        byte[][] tuple = new byte[2][0];
                                        tuple[0] = conn.getEncoding().encode( Integer.toString((int)index+i) ); // Index