Coverage Report

Coverage Report - org.melati.poem.dbms.Mckoi

Classes in this File

Line Coverage

Branch Coverage

Complexity

Mckoi

92%

35/38

66%

24/36

4.25

 /*
  * $Source$
  * $Revision$
  *
  * Copyright (C) 2002 Tim Pizey
  * 
  * Part of Melati (http://melati.org), a framework for the rapid
  * development of clean, maintainable web applications.
  *
  * Melati is free software; Permission is granted to copy, distribute
  * and/or modify this software under the terms either:
  *
  * a) the GNU General Public License as published by the Free Software
  *    Foundation; either version 2 of the License, or (at your option)
  *    any later version,
  *
  *    or
  *
  * b) any version of the Melati Software License, as published
  *    at http://melati.org
  *
  * You should have received a copy of the GNU General Public License and
  * the Melati Software License along with this program;
  * if not, write to the Free Software Foundation, Inc.,
  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA to obtain the
  * GNU General Public License and visit http://melati.org to obtain the
  * Melati Software License.
  *
  * Feel free to contact the Developers of Melati (http://melati.org),
  * if you would like to work out a different arrangement than the options
  * outlined here.  It is our intention to allow Melati to be used by as
  * wide an audience as possible.
  *
  * 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 General Public License for more details.
  *
  * Contact details for copyright holder:
  *
  *     Tim Pizey (timp At paneris.org)
  *
  */
 
 package org.melati.poem.dbms;
 
 import java.sql.SQLException;
 import java.sql.DatabaseMetaData;
 import java.sql.ResultSet;
 //import java.sql.ResultSetMetaData;
 import org.melati.poem.PoemType;
 import org.melati.poem.SQLPoemType;
 import org.melati.poem.DoublePoemType;
 import org.melati.poem.BinaryPoemType;
 import org.melati.poem.StringPoemType;
 
 /**
  * A Driver for Mckoidb (http://www.mckoi.com/).
 */
 public class Mckoi extends AnsiStandard {
 
   /** Size of text fields. */
   public static final int mckoiTextHack = 2147483647;
   
   /** Size of binary fields. */
   public static final int mckoiBinaryHack = 2147483647;
   /**
    * Constructor.
    */
   public Mckoi() {
     setDriverClassName("com.mckoi.JDBCDriver");
   }
 
   /**
    * {@inheritDoc}
    * @see org.melati.poem.dbms.AnsiStandard#getBinarySqlDefinition(int)
    */
   public String getBinarySqlDefinition(int size) {
       // BLOBs in Postgres are represented as OIDs pointing to the data
     return "LONGVARBINARY";
   }
 
   /**
    * {@inheritDoc}
    * @see org.melati.poem.dbms.AnsiStandard#getStringSqlDefinition(int)
    */
   public String getStringSqlDefinition(int size) throws SQLException {
     if (size < 0) { 
       return "TEXT";
     }
     return super.getStringSqlDefinition(size);
   }
 
   /**
    * {@inheritDoc}
    * @see org.melati.poem.dbms.AnsiStandard#getQuotedName(java.lang.String)
    */
   public String getQuotedName (String name) {
     //McKoi doesn't quote names
     if (name.equals("unique")) return super.getQuotedName(name);
     if (name.equals("from")) return super.getQuotedName(name);
     return name;
   }
 
  /**
    * TODO Check against modern McKoi
    */
   public String getSqlDefinition(String sqlTypeName) {
     if (sqlTypeName.equals("INT")) {
       return ("INTEGER");
     }
     /*
     if (sqlTypeName.equals("DOUBLE PRECISION")) {
       return ("DOUBLE");
     }
     */
     return super.getSqlDefinition(sqlTypeName);
   }
 
   /**
    * {@inheritDoc}
    * @see org.melati.poem.dbms.AnsiStandard#canRepresent
    */
   public <S,O>PoemType<O> canRepresent(PoemType<S> storage, PoemType<O> type) {
     if (storage instanceof StringPoemType &&
       type instanceof StringPoemType) {
 
       if (((StringPoemType)storage).getSize() == mckoiTextHack &&
           ((StringPoemType)type).getSize() == -1
           && !(!storage.getNullable() && type.getNullable())  // Nullable may represent not nullable
       ) {
            return type;
       } else {
         return storage.canRepresent(type);
       }
     } else if (storage instanceof BinaryPoemType &&
                type instanceof BinaryPoemType
                && !(!storage.getNullable() && type.getNullable())  // Nullable may represent not nullable
     ) {
       if (((BinaryPoemType)storage).getSize() == mckoiBinaryHack &&
           ((BinaryPoemType)type).getSize() == -1) {
         return type;
       } else {
         return storage.canRepresent(type);
       }
     } else {
       return storage.canRepresent(type);
     }
   }
 
   /**
    * {@inheritDoc}
    * @see org.melati.poem.dbms.AnsiStandard#defaultPoemTypeOfColumnMetaData
    */
   public SQLPoemType<?> defaultPoemTypeOfColumnMetaData(ResultSet md)
       throws SQLException {
 
     if(md.getString("TYPE_NAME").equals("NUMERIC"))
       return new DoublePoemType(md.getInt("NULLABLE")==
                                 DatabaseMetaData.columnNullable);
     else
       return super.defaultPoemTypeOfColumnMetaData(md);
   }
 
 
   /**
    * {@inheritDoc}
    * @see org.melati.poem.dbms.AnsiStandard#givesCapabilitySQL
    */
   public String givesCapabilitySQL(Integer userTroid, String capabilityExpr) {
     return
         "SELECT " + getQuotedName("groupmembership") + ".* " + 
         "FROM " + getQuotedName("groupmembership") + " LEFT JOIN " + 
         getQuotedName("groupcapability") +
         " ON " + getQuotedName("groupmembership") + "." + getQuotedName("group") +
         " =  " + getQuotedName("groupcapability") + "." + getQuotedName("group") + 
         " WHERE " + getQuotedName("user") + " = " + userTroid + " " +
         "AND " + getQuotedName("groupcapability") + "." + getQuotedName("group") + 
         " IS NOT NULL " +
         "AND " + getQuotedName("capability") + " = " + capabilityExpr;
   }
   
 }
 
 
 
 
 
 
 
 
 
 
 
 

1		/*
2		* $Source$
3		* $Revision$
4		*
5		* Copyright (C) 2002 Tim Pizey
6		*
7		* Part of Melati (http://melati.org), a framework for the rapid
8		* development of clean, maintainable web applications.
9		*
10		* Melati is free software; Permission is granted to copy, distribute
11		* and/or modify this software under the terms either:
12		*
13		* a) the GNU General Public License as published by the Free Software
14		* Foundation; either version 2 of the License, or (at your option)
15		* any later version,
16		*
17		* or
18		*
19		* b) any version of the Melati Software License, as published
20		* at http://melati.org
21		*
22		* You should have received a copy of the GNU General Public License and
23		* the Melati Software License along with this program;
24		* if not, write to the Free Software Foundation, Inc.,
25		* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA to obtain the
26		* GNU General Public License and visit http://melati.org to obtain the
27		* Melati Software License.
28		*
29		* Feel free to contact the Developers of Melati (http://melati.org),
30		* if you would like to work out a different arrangement than the options
31		* outlined here. It is our intention to allow Melati to be used by as
32		* wide an audience as possible.
33		*
34		* This program is distributed in the hope that it will be useful,
35		* but WITHOUT ANY WARRANTY; without even the implied warranty of
36		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
37		* GNU General Public License for more details.
38		*
39		* Contact details for copyright holder:
40		*
41		* Tim Pizey (timp At paneris.org)
42		*
43		*/
44
45		package org.melati.poem.dbms;
46
47		import java.sql.SQLException;
48		import java.sql.DatabaseMetaData;
49		import java.sql.ResultSet;
50		//import java.sql.ResultSetMetaData;
51		import org.melati.poem.PoemType;
52		import org.melati.poem.SQLPoemType;
53		import org.melati.poem.DoublePoemType;
54		import org.melati.poem.BinaryPoemType;
55		import org.melati.poem.StringPoemType;
56
57		/**
58		* A Driver for Mckoidb (http://www.mckoi.com/).
59		*/
60		public class Mckoi extends AnsiStandard {
61
62		/** Size of text fields. */
63		public static final int mckoiTextHack = 2147483647;
64
65		/** Size of binary fields. */
66		public static final int mckoiBinaryHack = 2147483647;
67		/**
68		* Constructor.
69		*/
70	1	public Mckoi() {
71	1	setDriverClassName("com.mckoi.JDBCDriver");
72	1	}
73
74		/**
75		* {@inheritDoc}
76		* @see org.melati.poem.dbms.AnsiStandard#getBinarySqlDefinition(int)
77		*/
78		public String getBinarySqlDefinition(int size) {
79		// BLOBs in Postgres are represented as OIDs pointing to the data
80	1	return "LONGVARBINARY";
81		}
82
83		/**
84		* {@inheritDoc}
85		* @see org.melati.poem.dbms.AnsiStandard#getStringSqlDefinition(int)
86		*/
87		public String getStringSqlDefinition(int size) throws SQLException {
88	2	if (size < 0) {
89	1	return "TEXT";
90		}
91	1	return super.getStringSqlDefinition(size);
92		}
93
94		/**
95		* {@inheritDoc}
96		* @see org.melati.poem.dbms.AnsiStandard#getQuotedName(java.lang.String)
97		*/
98		public String getQuotedName (String name) {
99		//McKoi doesn't quote names
100	26	if (name.equals("unique")) return super.getQuotedName(name);
101	26	if (name.equals("from")) return super.getQuotedName(name);
102	26	return name;
103		}
104
105		/**
106		* TODO Check against modern McKoi
107		*/
108		public String getSqlDefinition(String sqlTypeName) {
109	6	if (sqlTypeName.equals("INT")) {
110	1	return ("INTEGER");
111		}
112		/*
113		if (sqlTypeName.equals("DOUBLE PRECISION")) {
114		return ("DOUBLE");
115		}
116		*/
117	5	return super.getSqlDefinition(sqlTypeName);
118		}
119
120		/**
121		* {@inheritDoc}
122		* @see org.melati.poem.dbms.AnsiStandard#canRepresent
123		*/
124		public <S,O>PoemType<O> canRepresent(PoemType<S> storage, PoemType<O> type) {
125	17	if (storage instanceof StringPoemType &&
126		type instanceof StringPoemType) {
127
128	3	if (((StringPoemType)storage).getSize() == mckoiTextHack &&
129	1	((StringPoemType)type).getSize() == -1
130	1	&& !(!storage.getNullable() && type.getNullable()) // Nullable may represent not nullable
131		) {
132	1	return type;
133		} else {
134	2	return storage.canRepresent(type);
135		}
136	14	} else if (storage instanceof BinaryPoemType &&
137		type instanceof BinaryPoemType
138	4	&& !(!storage.getNullable() && type.getNullable()) // Nullable may represent not nullable
139		) {
140	3	if (((BinaryPoemType)storage).getSize() == mckoiBinaryHack &&
141	2	((BinaryPoemType)type).getSize() == -1) {
142	1	return type;
143		} else {
144	2	return storage.canRepresent(type);
145		}
146		} else {
147	11	return storage.canRepresent(type);
148		}
149		}
150
151		/**
152		* {@inheritDoc}
153		* @see org.melati.poem.dbms.AnsiStandard#defaultPoemTypeOfColumnMetaData
154		*/
155		public SQLPoemType<?> defaultPoemTypeOfColumnMetaData(ResultSet md)
156		throws SQLException {
157
158	0	if(md.getString("TYPE_NAME").equals("NUMERIC"))
159	0	return new DoublePoemType(md.getInt("NULLABLE")==
160		DatabaseMetaData.columnNullable);
161		else
162	0	return super.defaultPoemTypeOfColumnMetaData(md);
163		}
164
165
166		/**
167		* {@inheritDoc}
168		* @see org.melati.poem.dbms.AnsiStandard#givesCapabilitySQL
169		*/
170		public String givesCapabilitySQL(Integer userTroid, String capabilityExpr) {
171	1	return
172	1	"SELECT " + getQuotedName("groupmembership") + ".* " +
173	1	"FROM " + getQuotedName("groupmembership") + " LEFT JOIN " +
174	1	getQuotedName("groupcapability") +
175	1	" ON " + getQuotedName("groupmembership") + "." + getQuotedName("group") +
176	1	" = " + getQuotedName("groupcapability") + "." + getQuotedName("group") +
177	1	" WHERE " + getQuotedName("user") + " = " + userTroid + " " +
178	1	"AND " + getQuotedName("groupcapability") + "." + getQuotedName("group") +
179		" IS NOT NULL " +
180	1	"AND " + getQuotedName("capability") + " = " + capabilityExpr;
181		}
182
183		}
184
185
186
187
188
189
190
191
192
193
194
195